SYMBOL INDEX (15549 symbols across 1308 files)

FILE: crates/burn-autodiff/src/backend.rs
  type Autodiff (line 18) | pub struct Autodiff<B, C = NoCheckpointing> {
  type Device (line 24) | type Device = B::Device;
  type FloatTensorPrimitive (line 26) | type FloatTensorPrimitive = AutodiffTensor<B>;
  type FloatElem (line 27) | type FloatElem = B::FloatElem;
  type IntTensorPrimitive (line 29) | type IntTensorPrimitive = B::IntTensorPrimitive;
  type IntElem (line 30) | type IntElem = B::IntElem;
  type BoolTensorPrimitive (line 32) | type BoolTensorPrimitive = B::BoolTensorPrimitive;
  type BoolElem (line 33) | type BoolElem = B::BoolElem;
  type QuantizedTensorPrimitive (line 35) | type QuantizedTensorPrimitive = B::QuantizedTensorPrimitive;
  method ad_enabled (line 37) | fn ad_enabled(_device: &Self::Device) -> bool {
  method name (line 41) | fn name(device: &Self::Device) -> String {
  method seed (line 45) | fn seed(device: &B::Device, seed: u64) {
  method sync (line 49) | fn sync(device: &B::Device) -> Result<(), ExecutionError> {
  method memory_persistent_allocations (line 53) | fn memory_persistent_allocations<
  method memory_cleanup (line 65) | fn memory_cleanup(device: &Self::Device) {
  method staging (line 69) | fn staging<'a, Iter>(data: Iter, device: &Self::Device)
  method supports_dtype (line 76) | fn supports_dtype(device: &Self::Device, dtype: burn_std::DType) -> bool {
  method dtype_usage (line 80) | fn dtype_usage(device: &Self::Device, dtype: burn_std::DType) -> burn_ba...
  type InnerBackend (line 86) | type InnerBackend = B;
  type Gradients (line 87) | type Gradients = Gradients;
  method backward (line 89) | fn backward(tensor: AutodiffTensor<B>) -> Gradients {
  method grad (line 93) | fn grad(tensor: &AutodiffTensor<B>, grads: &Gradients) -> Option<B::Floa...
  method grad_remove (line 97) | fn grad_remove(
  method inner (line 103) | fn inner(tensor: AutodiffTensor<B>) -> B::FloatTensorPrimitive {
  method from_inner (line 107) | fn from_inner(tensor: B::FloatTensorPrimitive) -> AutodiffTensor<B> {
  method grad_replace (line 111) | fn grad_replace(
  method int_inner (line 119) | fn int_inner(tensor: IntTensor<Self>) -> IntTensor<Self::InnerBackend> {
  method bool_inner (line 123) | fn bool_inner(tensor: BoolTensor<Self>) -> BoolTensor<Self::InnerBackend> {
  method int_from_inner (line 127) | fn int_from_inner(tensor: IntTensor<Self::InnerBackend>) -> IntTensor<Se...
  method bool_from_inner (line 131) | fn bool_from_inner(tensor: BoolTensor<Self::InnerBackend>) -> BoolTensor...
  method q_inner (line 135) | fn q_inner(tensor: QuantizedTensor<Self>) -> QuantizedTensor<Self::Inner...
  method q_from_inner (line 139) | fn q_from_inner(tensor: QuantizedTensor<Self::InnerBackend>) -> Quantize...

FILE: crates/burn-autodiff/src/checkpoint/base.rs
  type NodeTree (line 12) | pub(crate) struct NodeTree {
    method parents (line 18) | pub(crate) fn parents(&self, node_id: &NodeId) -> Option<Vec<NodeId>> {
  type Checkpointer (line 25) | pub struct Checkpointer {
    method retrieve_node_output (line 34) | pub fn retrieve_node_output<T>(&mut self, node_id: NodeId) -> T
    method topological_sort (line 52) | fn topological_sort(&self, node_id: NodeId) -> Vec<NodeId> {
    method is_empty (line 79) | pub fn is_empty(&self) -> bool {

FILE: crates/burn-autodiff/src/checkpoint/builder.rs
  type CheckpointingAction (line 19) | pub enum CheckpointingAction {
    method id (line 41) | pub fn id(&self) -> NodeId {
  type CheckpointerBuilder (line 58) | pub struct CheckpointerBuilder {
    method checkpoint (line 77) | pub(crate) fn checkpoint<B: Backend>(
    method extend (line 102) | pub(crate) fn extend(&mut self, other: CheckpointerBuilder) {
    method build (line 111) | pub(crate) fn build(self, node_tree: NodeTree) -> Checkpointer {
    method find_stop_nodes (line 135) | fn find_stop_nodes(&self) -> Vec<NodeId> {
    method build_n_required_map (line 156) | fn build_n_required_map(
    method insert_checkpoints (line 197) | fn insert_checkpoints(
    method update_n_required_of_parents (line 249) | fn update_n_required_of_parents(
    method checkpoint_compute (line 277) | fn checkpoint_compute(
    method checkpoint_lazy (line 293) | fn checkpoint_lazy(
  type ActionType (line 66) | pub(crate) enum ActionType {

FILE: crates/burn-autodiff/src/checkpoint/retro_forward.rs
  type RetroForward (line 12) | pub trait RetroForward: Debug + Send + 'static {
    method forward (line 14) | fn forward(&self, states: &mut BackwardStates, out_node: NodeId);
  type RetroForwards (line 19) | pub(crate) struct RetroForwards {
    method execute_retro_forward (line 26) | pub(crate) fn execute_retro_forward(
    method is_empty (line 41) | pub(crate) fn is_empty(&self) -> bool {

FILE: crates/burn-autodiff/src/checkpoint/state.rs
  type StateContent (line 8) | pub(crate) type StateContent = Box<dyn Any + Send>;
  type State (line 15) | pub(crate) enum State {
    method to_state_content (line 27) | pub(crate) fn to_state_content(&self) -> &StateContent {
    method into_state_content (line 42) | pub(crate) fn into_state_content(self) -> StateContent {
    method n_required (line 57) | pub(crate) fn n_required(&self) -> usize {
  type BackwardStates (line 70) | pub struct BackwardStates {
    method get_state (line 78) | pub fn get_state<T>(&mut self, node_id: &NodeId) -> T
    method get_state_ref (line 117) | pub(crate) fn get_state_ref(&self, node_id: &NodeId) -> Option<&State> {
    method insert_state (line 122) | pub(crate) fn insert_state(&mut self, node_id: NodeId, state: State) {
    method save (line 127) | pub fn save<T>(&mut self, node_id: NodeId, saved_output: T)
    method is_empty (line 141) | pub(crate) fn is_empty(&self) -> bool {

FILE: crates/burn-autodiff/src/checkpoint/strategy.rs
  type CheckpointStrategy (line 14) | pub trait CheckpointStrategy: Clone + Copy + Debug + Default + Send + Sy...
    method compute_property (line 16) | fn compute_property<R: RetroForward>(retro_forward: R) -> ComputingPro...
    method checkpoint_parents (line 19) | fn checkpoint_parents<'a, B2, A>(
    method compute_property (line 42) | fn compute_property<R: RetroForward>(_retro_forward: R) -> ComputingPr...
    method checkpoint_parents (line 48) | fn checkpoint_parents<'a, B2, A>(
    method compute_property (line 68) | fn compute_property<R: RetroForward>(retro_forward: R) -> ComputingPro...
    method checkpoint_parents (line 77) | fn checkpoint_parents<'a, B2, A>(
  type CheckpointingError (line 30) | pub enum CheckpointingError {
  type NoCheckpointing (line 38) | pub struct NoCheckpointing {}
  type BalancedCheckpointing (line 63) | pub struct BalancedCheckpointing {}

FILE: crates/burn-autodiff/src/grads.rs
  type GradID (line 13) | pub type GradID = u64;
  type Gradients (line 16) | pub struct Gradients {
    method new (line 22) | pub fn new<B: Backend>(root_node: NodeRef, root_tensor: FloatTensor<B>...
    method consume (line 41) | pub fn consume<B: Backend>(&mut self, node: &NodeRef) -> FloatTensor<B> {
    method remove (line 58) | pub fn remove<B: Backend>(&mut self, tensor: &AutodiffTensor<B>) -> Op...
    method get (line 65) | pub fn get<B: Backend>(&self, tensor: &AutodiffTensor<B>) -> Option<Fl...
    method register (line 74) | pub fn register<B: Backend>(&mut self, node_id: NodeId, value: FloatTe...

FILE: crates/burn-autodiff/src/graph/base.rs
  type Step (line 6) | pub trait Step: Send + core::fmt::Debug {
    method step (line 8) | fn step(self: Box<Self>, grads: &mut Gradients, checkpointer: &mut Che...
    method depth (line 10) | fn depth(&self) -> usize;
    method node (line 12) | fn node(&self) -> NodeId;
    method parents (line 14) | fn parents(&self) -> &[Parent];
  type StepBoxed (line 17) | pub type StepBoxed = Box<dyn Step>;

FILE: crates/burn-autodiff/src/graph/node.rs
  type ComputingProperty (line 14) | pub enum ComputingProperty {
  type Node (line 33) | pub struct Node {
    method clone_if_require_grad (line 50) | pub fn clone_if_require_grad(self: &Arc<Self>) -> Option<NodeRef> {
  type NodeRef (line 41) | pub type NodeRef = Arc<Node>;
  type Parent (line 44) | pub struct Parent {
  type NodeId (line 60) | pub struct NodeId {
    method fmt (line 66) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method new (line 73) | pub fn new() -> Self {
  method default (line 84) | fn default() -> Self {

FILE: crates/burn-autodiff/src/graph/requirement.rs
  type Requirement (line 5) | pub enum Requirement {
    method is_none (line 16) | pub fn is_none(&self) -> bool {
    method from_nodes (line 20) | pub fn from_nodes(nodes: &[NodeRef]) -> Self {
    method infer (line 32) | fn infer(&self, other: &Self) -> Self {

FILE: crates/burn-autodiff/src/graph/traversal.rs
  type BreadthFirstSearch (line 10) | pub struct BreadthFirstSearch;
    method traverse (line 22) | pub fn traverse<F, I>(
  type TraversalItem (line 12) | pub trait TraversalItem {
    method id (line 13) | fn id(&self) -> NodeId;
    method parents (line 14) | fn parents(&self) -> &[Parent];
    method parent_nodes (line 15) | fn parent_nodes(&self) -> Vec<NodeId> {
    method id (line 67) | fn id(&self) -> NodeId {
    method parents (line 71) | fn parents(&self) -> &[Parent] {

FILE: crates/burn-autodiff/src/ops/activation.rs
  function gelu (line 17) | fn gelu(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function relu (line 55) | fn relu(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function sigmoid (line 92) | fn sigmoid(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function log_sigmoid (line 130) | fn log_sigmoid(tensor: FloatTensor<Self>) -> FloatTensor<Self> {

FILE: crates/burn-autodiff/src/ops/backward.rs
  type Backward (line 17) | pub trait Backward<B, const N: usize>: Send + core::fmt::Debug
    method backward (line 26) | fn backward(
    method prepare (line 34) | fn prepare<C: CheckpointStrategy>(
  function binary (line 50) | pub fn binary<B, FLhs, FRhs>(
  function unary (line 76) | pub fn unary<B, F>(parents: [Option<NodeRef>; 1], node: NodeRef, grads: ...

FILE: crates/burn-autodiff/src/ops/base.rs
  type OpsPrep (line 22) | pub struct OpsPrep<Backward, B, S, C, const N: usize, Mode = Init> {
  type Init (line 35) | pub struct Init;
  type MemoryBound (line 37) | pub struct MemoryBound;
  type MemoryBoundRetroForward (line 39) | pub struct MemoryBoundRetroForward;
  type ComputePropertyDone (line 41) | pub struct ComputePropertyDone;
  type Tracked (line 43) | pub struct Tracked;
  type UnTracked (line 45) | pub struct UnTracked;
  function compute_bound (line 54) | pub fn compute_bound(self) -> OpsPrep<BO, B, S, C, N, ComputePropertyDon...
  function memory_bound (line 66) | pub fn memory_bound(self) -> OpsPrep<BO, B, S, C, N, MemoryBound> {
  function retro_forward (line 84) | pub fn retro_forward<R: RetroForward>(
  function parents (line 105) | pub fn parents<'a, B2, A>(mut self, parents: A) -> OpsPrep<BO, B, S, C, ...
  function stateless (line 132) | pub fn stateless(self, output: FloatTensor<B>) -> AutodiffTensor<B> {
  function stateful (line 147) | pub fn stateful(self) -> OpsKind<BO, B, S, C, N> {
  function finish (line 174) | pub fn finish(self, output: FloatTensor<B>) -> AutodiffTensor<B> {
  function finish (line 197) | pub fn finish(self, state: S, output: FloatTensor<B>) -> AutodiffTensor<...
  function checkpoint (line 211) | pub fn checkpoint(&mut self, tensor: &AutodiffTensor<B>) -> NodeId {
  type OpsKind (line 220) | pub enum OpsKind<BO, B, S, C, const N: usize> {
  type Ops (line 229) | pub struct Ops<S, const N: usize> {
  type OpsStep (line 240) | struct OpsStep<B, T, SB, const N: usize>
  method step (line 257) | fn step(self: Box<Self>, grads: &mut Gradients, checkpointer: &mut Check...
  method node (line 261) | fn node(&self) -> NodeId {
  method parents (line 265) | fn parents(&self) -> &[Parent] {
  method depth (line 269) | fn depth(&self) -> usize {
  type UntrackedOpsStep (line 275) | struct UntrackedOpsStep<const N: usize> {
  method step (line 280) | fn step(self: Box<Self>, _grads: &mut Gradients, _checkpointer: &mut Che...
  method node (line 284) | fn node(&self) -> NodeId {
  method parents (line 288) | fn parents(&self) -> &[Parent] {
  method depth (line 291) | fn depth(&self) -> usize {
  function broadcast_shape (line 300) | pub fn broadcast_shape<B: Backend>(mut grad: FloatTensor<B>, shape: &Sha...

FILE: crates/burn-autodiff/src/ops/bool_tensor.rs
  function bool_from_data (line 12) | fn bool_from_data(data: TensorData, device: &Device<B>) -> BoolTensor<B> {
  function bool_into_data (line 16) | async fn bool_into_data(tensor: BoolTensor<B>) -> Result<TensorData, Exe...
  function bool_into_int (line 20) | fn bool_into_int(tensor: BoolTensor<B>) -> IntTensor<B> {
  function bool_to_device (line 24) | fn bool_to_device(tensor: BoolTensor<B>, device: &Device<B>) -> BoolTens...
  function bool_device (line 28) | fn bool_device(tensor: &BoolTensor<B>) -> Device<B> {
  function bool_reshape (line 32) | fn bool_reshape(tensor: BoolTensor<B>, shape: Shape) -> BoolTensor<B> {
  function bool_slice (line 36) | fn bool_slice(tensor: BoolTensor<B>, slices: &[burn_std::Slice]) -> Bool...
  function bool_empty (line 40) | fn bool_empty(shape: Shape, device: &Device<B>) -> BoolTensor<B> {
  function bool_zeros (line 44) | fn bool_zeros(shape: Shape, device: &Device<B>) -> BoolTensor<B> {
  function bool_ones (line 48) | fn bool_ones(shape: Shape, device: &Device<B>) -> BoolTensor<B> {
  function bool_slice_assign (line 52) | fn bool_slice_assign(
  function bool_cat (line 60) | fn bool_cat(tensors: Vec<BoolTensor<B>>, dim: usize) -> BoolTensor<B> {
  function bool_equal (line 64) | fn bool_equal(lhs: BoolTensor<B>, rhs: BoolTensor<B>) -> BoolTensor<B> {
  function bool_not (line 68) | fn bool_not(tensor: BoolTensor<B>) -> BoolTensor<B> {
  function bool_and (line 72) | fn bool_and(lhs: BoolTensor<B>, rhs: BoolTensor<B>) -> BoolTensor<B> {
  function bool_or (line 76) | fn bool_or(lhs: BoolTensor<B>, rhs: BoolTensor<B>) -> BoolTensor<B> {
  function bool_xor (line 80) | fn bool_xor(lhs: BoolTensor<B>, rhs: BoolTensor<B>) -> BoolTensor<B> {
  function bool_into_float (line 84) | fn bool_into_float(tensor: BoolTensor<B>) -> <Autodiff<B> as Backend>::F...
  function bool_swap_dims (line 88) | fn bool_swap_dims(
  function bool_permute (line 96) | fn bool_permute(tensor: BoolTensor<Self>, axes: &[usize]) -> BoolTensor<...
  function bool_flip (line 100) | fn bool_flip(tensor: BoolTensor<B>, axes: &[usize]) -> BoolTensor<B> {
  function bool_argwhere (line 104) | async fn bool_argwhere(tensor: BoolTensor<B>) -> IntTensor<B> {
  function bool_expand (line 108) | fn bool_expand(tensor: BoolTensor<B>, shape: Shape) -> BoolTensor<B> {
  function bool_repeat_dim (line 112) | fn bool_repeat_dim(tensor: BoolTensor<B>, dim: usize, times: usize) -> B...
  function bool_unfold (line 116) | fn bool_unfold(
  function bool_mask_where (line 125) | fn bool_mask_where(
  function bool_mask_fill (line 133) | fn bool_mask_fill(
  function bool_gather (line 141) | fn bool_gather(
  function bool_scatter_or (line 149) | fn bool_scatter_or(
  function bool_equal_elem (line 158) | fn bool_equal_elem(lhs: BoolTensor<Self>, rhs: Scalar) -> BoolTensor<Sel...

FILE: crates/burn-autodiff/src/ops/int_tensor.rs
  function int_from_data (line 12) | fn int_from_data(data: TensorData, device: &Device<Self>) -> IntTensor<B> {
  function int_into_data (line 16) | async fn int_into_data(tensor: IntTensor<B>) -> Result<TensorData, Execu...
  function int_to_device (line 20) | fn int_to_device(tensor: IntTensor<B>, device: &Device<Self>) -> IntTens...
  function int_device (line 24) | fn int_device(tensor: &IntTensor<B>) -> Device<Self> {
  function int_reshape (line 28) | fn int_reshape(tensor: IntTensor<B>, shape: Shape) -> IntTensor<B> {
  function int_slice (line 32) | fn int_slice(tensor: IntTensor<B>, slices: &[burn_std::Slice]) -> IntTen...
  function int_empty (line 36) | fn int_empty(
  function int_slice_assign (line 44) | fn int_slice_assign(
  function int_cat (line 52) | fn int_cat(tensors: Vec<IntTensor<B>>, dim: usize) -> IntTensor<B> {
  function int_equal (line 56) | fn int_equal(lhs: IntTensor<B>, rhs: IntTensor<B>) -> BoolTensor<B> {
  function int_equal_elem (line 60) | fn int_equal_elem(lhs: IntTensor<B>, rhs: Scalar) -> BoolTensor<B> {
  function int_add (line 64) | fn int_add(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B> {
  function int_add_scalar (line 68) | fn int_add_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B> {
  function int_clamp_min (line 72) | fn int_clamp_min(tensor: IntTensor<B>, min: Scalar) -> IntTensor<B> {
  function int_clamp_max (line 76) | fn int_clamp_max(tensor: IntTensor<B>, max: Scalar) -> IntTensor<B> {
  function int_clamp (line 80) | fn int_clamp(tensor: IntTensor<B>, min: Scalar, max: Scalar) -> IntTenso...
  function int_sub (line 84) | fn int_sub(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B> {
  function int_sub_scalar (line 88) | fn int_sub_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B> {
  function int_mul (line 92) | fn int_mul(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B> {
  function int_mul_scalar (line 96) | fn int_mul_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B> {
  function int_div (line 100) | fn int_div(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B> {
  function int_div_scalar (line 104) | fn int_div_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B> {
  function int_remainder (line 108) | fn int_remainder(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B> {
  function int_remainder_scalar (line 112) | fn int_remainder_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B> {
  function int_matmul (line 116) | fn int_matmul(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B> {
  function int_neg (line 120) | fn int_neg(tensor: IntTensor<B>) -> IntTensor<B> {
  function int_zeros (line 124) | fn int_zeros(shape: Shape, device: &Device<Self>, dtype: IntDType) -> In...
  function int_ones (line 128) | fn int_ones(shape: Shape, device: &Device<Self>, dtype: IntDType) -> Int...
  function int_full (line 132) | fn int_full(
  function int_sum (line 141) | fn int_sum(tensor: IntTensor<B>) -> IntTensor<B> {
  function int_sum_dim (line 145) | fn int_sum_dim(tensor: IntTensor<B>, dim: usize) -> IntTensor<B> {
  function int_mean (line 149) | fn int_mean(tensor: IntTensor<B>) -> IntTensor<B> {
  function int_mean_dim (line 153) | fn int_mean_dim(tensor: IntTensor<B>, dim: usize) -> IntTensor<B> {
  function int_cumsum (line 157) | fn int_cumsum(tensor: IntTensor<B>, dim: usize) -> IntTensor<B> {
  function int_cumprod (line 161) | fn int_cumprod(tensor: IntTensor<B>, dim: usize) -> IntTensor<B> {
  function int_cummin (line 165) | fn int_cummin(tensor: IntTensor<B>, dim: usize) -> IntTensor<B> {
  function int_cummax (line 169) | fn int_cummax(tensor: IntTensor<B>, dim: usize) -> IntTensor<B> {
  function int_repeat_dim (line 173) | fn int_repeat_dim(tensor: IntTensor<B>, dim: usize, times: usize) -> Int...
  function int_greater (line 177) | fn int_greater(lhs: IntTensor<B>, rhs: IntTensor<B>) -> BoolTensor<B> {
  function int_greater_elem (line 181) | fn int_greater_elem(lhs: IntTensor<B>, rhs: Scalar) -> BoolTensor<B> {
  function int_greater_equal (line 185) | fn int_greater_equal(lhs: IntTensor<B>, rhs: IntTensor<B>) -> BoolTensor...
  function int_greater_equal_elem (line 189) | fn int_greater_equal_elem(lhs: IntTensor<B>, rhs: Scalar) -> BoolTensor<...
  function int_lower (line 193) | fn int_lower(lhs: IntTensor<B>, rhs: IntTensor<B>) -> BoolTensor<B> {
  function int_lower_elem (line 197) | fn int_lower_elem(lhs: IntTensor<B>, rhs: Scalar) -> BoolTensor<B> {
  function int_lower_equal (line 201) | fn int_lower_equal(lhs: IntTensor<B>, rhs: IntTensor<B>) -> BoolTensor<B> {
  function int_lower_equal_elem (line 205) | fn int_lower_equal_elem(lhs: IntTensor<B>, rhs: Scalar) -> BoolTensor<B> {
  function int_gather (line 209) | fn int_gather(dim: usize, tensor: IntTensor<B>, indices: IntTensor<B>) -...
  function int_scatter_add (line 213) | fn int_scatter_add(
  function int_select (line 222) | fn int_select(tensor: IntTensor<B>, dim: usize, indices: IntTensor<B>) -...
  function int_select_add (line 226) | fn int_select_add(
  function int_mask_where (line 235) | fn int_mask_where(
  function int_mask_fill (line 243) | fn int_mask_fill(
  function int_argmax (line 251) | fn int_argmax(tensor: IntTensor<B>, dim: usize) -> IntTensor<B> {
  function int_argmin (line 254) | fn int_argmin(tensor: IntTensor<B>, dim: usize) -> IntTensor<B> {
  function int_max (line 257) | fn int_max(tensor: B::IntTensorPrimitive) -> B::IntTensorPrimitive {
  function int_max_dim (line 260) | fn int_max_dim(tensor: B::IntTensorPrimitive, dim: usize) -> B::IntTenso...
  function int_max_dim_with_indices (line 263) | fn int_max_dim_with_indices(
  function int_min (line 269) | fn int_min(tensor: B::IntTensorPrimitive) -> B::IntTensorPrimitive {
  function int_min_dim (line 272) | fn int_min_dim(tensor: B::IntTensorPrimitive, dim: usize) -> B::IntTenso...
  function int_min_dim_with_indices (line 275) | fn int_min_dim_with_indices(
  function int_abs (line 281) | fn int_abs(tensor: B::IntTensorPrimitive) -> B::IntTensorPrimitive {
  function int_into_float (line 284) | fn int_into_float(
  function int_swap_dims (line 290) | fn int_swap_dims(
  function int_random (line 298) | fn int_random(
  function int_arange (line 306) | fn int_arange(range: core::ops::Range<i64>, device: &Device<Self>) -> In...
  function int_permute (line 310) | fn int_permute(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Sel...
  function int_flip (line 314) | fn int_flip(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Self> {
  function int_sign (line 318) | fn int_sign(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_prod (line 322) | fn int_prod(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_prod_dim (line 326) | fn int_prod_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_expand (line 330) | fn int_expand(tensor: IntTensor<B>, shape: Shape) -> IntTensor<B> {
  function int_sort (line 334) | fn int_sort(tensor: IntTensor<Self>, dim: usize, descending: bool) -> In...
  function int_sort_with_indices (line 338) | fn int_sort_with_indices(
  function int_argsort (line 346) | fn int_argsort(tensor: IntTensor<Self>, dim: usize, descending: bool) ->...
  function bitwise_and (line 350) | fn bitwise_and(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  function bitwise_and_scalar (line 354) | fn bitwise_and_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  function bitwise_or (line 358) | fn bitwise_or(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  function bitwise_or_scalar (line 362) | fn bitwise_or_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Sel...
  function bitwise_xor (line 366) | fn bitwise_xor(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  function bitwise_xor_scalar (line 370) | fn bitwise_xor_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  function bitwise_not (line 374) | fn bitwise_not(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function bitwise_left_shift (line 378) | fn bitwise_left_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> Int...
  function bitwise_left_shift_scalar (line 382) | fn bitwise_left_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTe...
  function bitwise_right_shift (line 386) | fn bitwise_right_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> In...
  function bitwise_right_shift_scalar (line 390) | fn bitwise_right_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntT...
  function int_cast (line 394) | fn int_cast(tensor: IntTensor<Self>, dtype: IntDType) -> IntTensor<Self> {
  function int_unfold (line 398) | fn int_unfold(

FILE: crates/burn-autodiff/src/ops/maxmin.rs
  type MaxMinDim (line 7) | pub(crate) struct MaxMinDim;
    type State (line 10) | type State = (B::IntTensorPrimitive, Shape, usize);
    method backward (line 12) | fn backward(

FILE: crates/burn-autodiff/src/ops/module.rs
  function embedding (line 17) | fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> Autod...
  function embedding_backward (line 51) | fn embedding_backward(
  function conv1d (line 59) | fn conv1d(
  function conv_transpose1d (line 182) | fn conv_transpose1d(
  function conv2d (line 317) | fn conv2d(
  function deform_conv2d (line 443) | fn deform_conv2d(
  function deform_conv2d_backward (line 768) | fn deform_conv2d_backward(
  function conv_transpose2d (line 780) | fn conv_transpose2d(
  function conv3d (line 917) | fn conv3d(
  function conv_transpose3d (line 1043) | fn conv_transpose3d(
  function avg_pool1d (line 1195) | fn avg_pool1d(
  function avg_pool2d (line 1273) | fn avg_pool2d(
  function avg_pool2d_backward (line 1351) | fn avg_pool2d_backward(
  function max_pool1d (line 1363) | fn max_pool1d(
  function max_pool1d_with_indices (line 1410) | fn max_pool1d_with_indices(
  function max_pool1d_with_indices_backward (line 1465) | fn max_pool1d_with_indices_backward(
  function max_pool2d (line 1488) | fn max_pool2d(
  function max_pool2d_with_indices (line 1535) | fn max_pool2d_with_indices(
  function max_pool2d_with_indices_backward (line 1591) | fn max_pool2d_with_indices_backward(
  function adaptive_avg_pool1d (line 1603) | fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> Auto...
  function adaptive_avg_pool2d (line 1642) | fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) ->...
  function adaptive_avg_pool2d_backward (line 1681) | fn adaptive_avg_pool2d_backward(
  function interpolate (line 1688) | fn interpolate(
  function interpolate_backward (line 1733) | fn interpolate_backward(
  function attention (line 1742) | fn attention(
  type MaxPool1D (line 1755) | struct MaxPool1D;
    type State (line 1758) | type State = (NodeId, IntTensor<B>, usize, usize, usize, usize, bool);
    method backward (line 1760) | fn backward(
  type MaxPool2D (line 1789) | struct MaxPool2D;
    type State (line 1792) | type State = (
    method backward (line 1802) | fn backward(

FILE: crates/burn-autodiff/src/ops/qtensor.rs
  function q_from_data (line 14) | fn q_from_data(_data: TensorData, _device: &Device<Self>) -> QuantizedTe...
  function quantize (line 18) | fn quantize(
  function quantize_dynamic (line 26) | fn quantize_dynamic(
  function dequantize (line 33) | fn dequantize(_tensor: QuantizedTensor<Self>) -> FloatTensor<Self> {
  function q_device (line 37) | fn q_device(tensor: &QuantizedTensor<Self>) -> Device<Self> {
  function q_to_device (line 41) | fn q_to_device(
  function q_reshape (line 48) | fn q_reshape(tensor: QuantizedTensor<Self>, shape: Shape) -> QuantizedTe...
  function q_into_data (line 52) | async fn q_into_data(tensor: QuantizedTensor<Self>) -> Result<TensorData...
  function q_swap_dims (line 56) | fn q_swap_dims(
  function q_permute (line 64) | fn q_permute(_tensor: QuantizedTensor<Self>, _axes: &[usize]) -> Quantiz...
  function q_flip (line 68) | fn q_flip(_tensor: QuantizedTensor<Self>, _axes: &[usize]) -> QuantizedT...
  function q_gather (line 72) | fn q_gather(
  function q_select (line 80) | fn q_select(
  function q_slice (line 88) | fn q_slice(
  function q_argmax (line 95) | fn q_argmax(tensor: QuantizedTensor<Self>, dim: usize) -> IntTensor<Self> {
  function q_argmin (line 99) | fn q_argmin(tensor: QuantizedTensor<Self>, dim: usize) -> IntTensor<Self> {
  function q_expand (line 103) | fn q_expand(_tensor: QuantizedTensor<Self>, _shape: Shape) -> QuantizedT...

FILE: crates/burn-autodiff/src/ops/sort.rs
  type SortDim (line 7) | pub(crate) struct SortDim;
    type State (line 10) | type State = (B::IntTensorPrimitive, Shape, usize);
    method backward (line 12) | fn backward(

FILE: crates/burn-autodiff/src/ops/tensor.rs
  function unsqueeze_like (line 33) | fn unsqueeze_like<B: Backend>(
  function float_from_data (line 54) | fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTens...
  function float_random (line 58) | fn float_random(
  function float_zeros (line 66) | fn float_zeros(shape: Shape, device: &Device<Self>, dtype: FloatDType) -...
  function float_ones (line 70) | fn float_ones(shape: Shape, device: &Device<Self>, dtype: FloatDType) ->...
  function float_into_data (line 83) | async fn float_into_data(tensor: FloatTensor<Self>) -> Result<TensorData...
  function float_device (line 87) | fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {
  function float_to_device (line 100) | fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> ...
  function float_empty (line 132) | fn float_empty(shape: Shape, device: &Device<Self>, dtype: FloatDType) -...
  function float_add (line 136) | fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_add_scalar (line 178) | fn float_add_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_sub (line 205) | fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_sub_scalar (line 247) | fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_mul (line 274) | fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_mul_scalar (line 333) | fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_div (line 366) | fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_div_scalar (line 434) | fn float_div_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_remainder (line 468) | fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Fl...
  function float_remainder_scalar (line 534) | fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatT...
  function float_matmul (line 561) | fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Float...
  function float_cross (line 619) | fn float_cross(
  function float_neg (line 672) | fn float_neg(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_recip (line 698) | fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_swap_dims (line 738) | fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) ...
  function float_permute (line 792) | fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTens...
  function float_flip (line 847) | fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<...
  function float_reshape (line 897) | fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor...
  function float_gather (line 958) | fn float_gather(
  function float_scatter_add (line 1004) | fn float_scatter_add(
  function float_select (line 1053) | fn float_select(
  function float_select_add (line 1116) | fn float_select_add(
  function float_slice (line 1188) | fn float_slice(tensor: FloatTensor<Self>, slices: &[Slice]) -> FloatTens...
  function float_slice_assign (line 1244) | fn float_slice_assign(
  function float_mask_where (line 1321) | fn float_mask_where(
  function float_mask_fill (line 1383) | fn float_mask_fill(
  function float_equal (line 1421) | fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTe...
  function float_equal_elem (line 1425) | fn float_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor<B> {
  function float_greater (line 1429) | fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Bool...
  function float_greater_elem (line 1433) | fn float_greater_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor...
  function float_greater_equal (line 1437) | fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -...
  function float_greater_equal_elem (line 1441) | fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> Bool...
  function float_lower (line 1445) | fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTe...
  function float_lower_elem (line 1449) | fn float_lower_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor<B> {
  function float_lower_equal (line 1453) | fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> ...
  function float_lower_equal_elem (line 1457) | fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTe...
  function float_is_nan (line 1461) | fn float_is_nan(tensor: FloatTensor<Self>) -> BoolTensor<Self> {
  function float_is_inf (line 1465) | fn float_is_inf(tensor: FloatTensor<Self>) -> BoolTensor<Self> {
  function float_detach (line 1469) | fn float_detach(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_set_require_grad (line 1481) | fn float_set_require_grad(tensor: FloatTensor<Self>, require_grad: bool)...
  function float_is_require_grad (line 1489) | fn float_is_require_grad(tensor: &FloatTensor<Self>) -> bool {
  function float_mean (line 1493) | fn float_mean(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sum (line 1526) | fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_mean_dim (line 1557) | fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<...
  function float_sum_dim (line 1596) | fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_cumsum (line 1633) | fn float_cumsum(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_cumprod (line 1670) | fn float_cumprod(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_cummin (line 1728) | fn float_cummin(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_cummax (line 1793) | fn float_cummax(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_argmax (line 1858) | fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {
  function float_argmin (line 1862) | fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {
  function float_exp (line 1866) | fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_log (line 1904) | fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_log1p (line 1942) | fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_powf_scalar_impl (line 1982) | fn float_powf_scalar_impl(tensor: FloatTensor<Self>, value: Scalar) -> F...
  function float_sqrt (line 2037) | fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_abs (line 2079) | fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cos (line 2117) | fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sin (line 2156) | fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_tanh (line 2194) | fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cosh (line 2236) | fn float_cosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sinh (line 2273) | fn float_sinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_tan (line 2310) | fn float_tan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asin (line 2350) | fn float_asin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_acos (line 2390) | fn float_acos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan (line 2431) | fn float_atan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asinh (line 2471) | fn float_asinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_acosh (line 2512) | fn float_acosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atanh (line 2553) | fn float_atanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan2 (line 2594) | fn float_atan2(y: FloatTensor<Self>, x: FloatTensor<Self>) -> FloatTenso...
  function float_round (line 2672) | fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_floor (line 2708) | fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_ceil (line 2744) | fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_trunc (line 2780) | fn float_trunc(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_erf (line 2816) | fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cat (line 2858) | fn float_cat(tensors: Vec<FloatTensor<Self>>, dim: usize) -> FloatTensor...
  function float_max_dim (line 2952) | fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_max_dim_with_indices (line 2966) | fn float_max_dim_with_indices(
  function float_min_dim (line 2991) | fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_min_dim_with_indices (line 3005) | fn float_min_dim_with_indices(
  function float_into_int (line 3030) | fn float_into_int(tensor: FloatTensor<Self>) -> <Autodiff<B> as Backend>...
  function float_powf (line 3034) | fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTe...
  function float_sign (line 3110) | fn float_sign(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_expand (line 3139) | fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<...
  function float_sort (line 3211) | fn float_sort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -...
  function float_sort_with_indices (line 3229) | fn float_sort_with_indices(
  function float_argsort (line 3257) | fn float_argsort(tensor: FloatTensor<Self>, dim: usize, descending: bool...
  function float_repeat_dim (line 3261) | fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize)...
  function float_cast (line 3326) | fn float_cast(tensor: FloatTensor<Self>, dtype: burn_std::FloatDType) ->...
  function float_unfold (line 3363) | fn float_unfold(
  type BinaryOpsBroadcast (line 3447) | enum BinaryOpsBroadcast {
    method new (line 3453) | fn new<B: Backend>(lhs: &B::FloatTensorPrimitive, rhs: &B::FloatTensor...
    method backward_lhs (line 3467) | fn backward_lhs<B: Backend>(&self, grad: B::FloatTensorPrimitive) -> B...
    method backward_rhs (line 3474) | fn backward_rhs<B: Backend>(&self, grad: B::FloatTensorPrimitive) -> B...

FILE: crates/burn-autodiff/src/ops/transaction.rs
  function tr_execute (line 9) | async fn tr_execute(

FILE: crates/burn-autodiff/src/runtime/client.rs
  type AutodiffClient (line 10) | pub trait AutodiffClient: Send + Clone {
    method register (line 12) | fn register(&self, node_id: NodeRefCount, step: StepBoxed, actions: Ch...
    method backward (line 14) | fn backward<B: Backend>(&self, tensor: AutodiffTensor<B>) -> Gradients;
  type AutodiffClientImpl (line 18) | pub type AutodiffClientImpl = super::graph::GraphMutexClient;

FILE: crates/burn-autodiff/src/runtime/graph.rs
  type GraphMutexClient (line 32) | pub struct GraphMutexClient;
    method graph (line 84) | fn graph(node: NodeId, parents: &[Parent]) -> Arc<Graph> {
  type GraphLocator (line 43) | pub struct GraphLocator {
    method select (line 188) | pub(crate) fn select(&mut self, node: NodeId, parents: &[Parent]) -> A...
    method analyse (line 203) | fn analyse(&mut self, node: NodeId, parents: &[Parent]) -> GraphAnalys...
    method merge (line 242) | fn merge(&mut self, node: NodeId, mut graphs: HashMap<NodeId, Arc<Grap...
    method register_key (line 263) | fn register_key(&mut self, origin: NodeId, key: NodeId) {
    method merge_two (line 276) | fn merge_two(&mut self, main_state: &mut GraphState, main: &Arc<Graph>...
    method new_graph (line 300) | fn new_graph(&mut self, origin: NodeId) -> Arc<Graph> {
    method remove_entry (line 310) | fn remove_entry(&mut self, node: &NodeId) {
  type Graph (line 55) | pub(crate) struct Graph {
    method fmt (line 66) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type GraphState (line 61) | struct GraphState {
  method register (line 100) | fn register(&self, node_id_ref: NodeRefCount, step: StepBoxed, actions: ...
  method backward (line 108) | fn backward<B: Backend>(&self, root: AutodiffTensor<B>) -> Gradients {
  type GraphCleaner (line 124) | struct GraphCleaner<'a> {
  function cleanup_orphaned_entries (line 129) | fn cleanup_orphaned_entries() {
  method init (line 164) | fn init() -> Self {
  method clean (line 169) | fn clean(&mut self, node: &NodeId) {
  type GraphAnalysis (line 330) | enum GraphAnalysis {

FILE: crates/burn-autodiff/src/runtime/memory_management.rs
  type GraphMemoryManagement (line 11) | pub struct GraphMemoryManagement {
    method extend (line 25) | pub fn extend(&mut self, other: Self) {
    method register (line 32) | pub fn register(&mut self, node: NodeRefCount, parents: &[Parent]) {
    method consume_node (line 45) | pub fn consume_node(&mut self, node_id: NodeId) {
    method free_unavailable_nodes (line 56) | pub(crate) fn free_unavailable_nodes(&mut self, mut on_free_graph: imp...
    method free_unused_roots (line 92) | pub(crate) fn free_unused_roots(&mut self, mut on_free_graph: impl FnM...
    method clear_unused_roots (line 102) | fn clear_unused_roots(&self, to_delete: &mut Vec<NodeId>) {
    method unavailable_propagation (line 118) | fn unavailable_propagation(&mut self, node_id: NodeId) -> NodeMemorySt...
    method useful_propagation (line 148) | fn useful_propagation(&mut self, leaves: HashSet<NodeId>) {
    method identify_leaves_and_deletables (line 218) | fn identify_leaves_and_deletables(
    method is_referenced (line 257) | fn is_referenced(&self, node_id: NodeId) -> bool {
    method maybe_useful (line 264) | pub(crate) fn maybe_useful(&self) -> bool {
  type NodeMemoryStatus (line 18) | enum NodeMemoryStatus {
  type PopNodeSet (line 271) | struct PopNodeSet {
    method pop (line 277) | fn pop(&mut self) -> Option<NodeId> {
    method contains (line 286) | fn contains(&self, node_id: &NodeId) -> bool {
    method insert (line 291) | fn insert(&mut self, node_id: NodeId) {

FILE: crates/burn-autodiff/src/runtime/server.rs
  type AutodiffServer (line 16) | pub struct AutodiffServer {
    method extend (line 31) | pub fn extend(&mut self, other: AutodiffServer) {
    method register (line 37) | pub fn register(&mut self, rc: NodeRefCount, step: StepBoxed, actions:...
    method backward (line 47) | pub fn backward<NC: NodeCleaner>(&mut self, grads: Gradients, node_id:...
    method free_unused_roots (line 74) | pub(crate) fn free_unused_roots(&mut self, mut on_free_graph: impl FnM...
    method build_tape (line 82) | fn build_tape(
    method execute_steps (line 122) | fn execute_steps(
    method maybe_useful (line 140) | pub(crate) fn maybe_useful(&self) -> bool {
  type NodeCleaner (line 23) | pub trait NodeCleaner {
    method init (line 25) | fn init() -> Self;
    method clean (line 27) | fn clean(&mut self, node: &NodeId);

FILE: crates/burn-autodiff/src/tensor.rs
  type AutodiffTensor (line 11) | pub struct AutodiffTensor<B: Backend> {
  method dtype (line 18) | fn dtype(&self) -> burn_std::DType {
  method shape (line 22) | fn shape(&self) -> burn_std::Shape {
  method rank (line 26) | fn rank(&self) -> usize {
  type NodeRefCount (line 31) | pub type NodeRefCount = Arc<NodeId>;
  type RootStep (line 34) | pub(crate) struct RootStep {
  method step (line 39) | fn step(self: Box<Self>, _grads: &mut Gradients, _checkpointer: &mut Che...
  method node (line 43) | fn node(&self) -> NodeId {
  method parents (line 47) | fn parents(&self) -> &[Parent] {
  method depth (line 51) | fn depth(&self) -> usize {
  function new (line 58) | pub fn new(primitive: B::FloatTensorPrimitive) -> Self {
  function is_tracked (line 77) | pub fn is_tracked(&self) -> bool {
  function require_grad (line 86) | pub fn require_grad(mut self) -> Self {
  function from_parents (line 110) | pub fn from_parents(
  function register_step (line 154) | pub fn register_step<S: Step + 'static>(
  function into_primitive (line 167) | pub fn into_primitive(self) -> B::FloatTensorPrimitive {
  function backward (line 171) | pub fn backward(self) -> Gradients {
  function grad (line 177) | pub fn grad(&self, grads: &Gradients) -> Option<B::FloatTensorPrimitive> {
  function grad_remove (line 181) | pub fn grad_remove(&self, grads: &mut Gradients) -> Option<B::FloatTenso...
  function grad_replace (line 185) | pub fn grad_replace(&self, grads: &mut Gradients, grad: B::FloatTensorPr...

FILE: crates/burn-autodiff/src/utils.rs
  function duplicate (line 12) | pub fn duplicate<T: Clone + core::fmt::Debug, const N: usize>(

FILE: crates/burn-backend-tests/tests/autodiff.rs
  type FloatElemType (line 10) | pub type FloatElemType = f32;
  type IntElemType (line 12) | pub type IntElemType = i32;

FILE: crates/burn-backend-tests/tests/autodiff/abs.rs
  function should_diff_abs (line 5) | fn should_diff_abs() {
  function should_diff_abs_no_nans (line 32) | fn should_diff_abs_no_nans() {

FILE: crates/burn-backend-tests/tests/autodiff/adaptive_avgpool1d.rs
  function test_avg_pool1d_simple (line 6) | fn test_avg_pool1d_simple() {
  type AdaptiveAvgPool1dTestCase (line 23) | struct AdaptiveAvgPool1dTestCase {
    method assert_output (line 31) | fn assert_output(self, x_grad: TestTensor<3>) {

FILE: crates/burn-backend-tests/tests/autodiff/adaptive_avgpool2d.rs
  function test_avg_pool2d_simple (line 6) | fn test_avg_pool2d_simple() {
  function test_avg_pool2d_output_1 (line 38) | fn test_avg_pool2d_output_1() {
  type AdaptiveAvgPool2dTestCase (line 67) | struct AdaptiveAvgPool2dTestCase {
    method assert_output (line 77) | fn assert_output(self, x_grad: TestTensor<4>) {

FILE: crates/burn-backend-tests/tests/autodiff/add.rs
  function should_diff_add (line 5) | fn should_diff_add() {
  function should_diff_add_scalar (line 28) | fn should_diff_add_scalar() {
  function test_add_complex_1 (line 45) | fn test_add_complex_1() {

FILE: crates/burn-backend-tests/tests/autodiff/aggregation.rs
  function should_diff_mean (line 5) | fn should_diff_mean() {
  function should_diff_sum_1 (line 32) | fn should_diff_sum_1() {
  function should_diff_sum_2 (line 59) | fn should_diff_sum_2() {
  function should_diff_mean_dim (line 87) | fn should_diff_mean_dim() {
  function should_diff_sum_dim (line 114) | fn should_diff_sum_dim() {

FILE: crates/burn-backend-tests/tests/autodiff/avgpool1d.rs
  function test_avg_pool1d_simple (line 6) | fn test_avg_pool1d_simple() {
  function test_avg_pool1d_complex (line 24) | fn test_avg_pool1d_complex() {
  function test_avg_pool1d_complex_dont_count_pad (line 45) | fn test_avg_pool1d_complex_dont_count_pad() {
  type AvgPool1dTestCase (line 65) | struct AvgPool1dTestCase {
    method assert_output (line 76) | fn assert_output(self, x_grad: TestTensor<3>) {

FILE: crates/burn-backend-tests/tests/autodiff/avgpool2d.rs
  function test_avg_pool2d_simple (line 6) | fn test_avg_pool2d_simple() {
  function test_avg_pool2d_complex (line 35) | fn test_avg_pool2d_complex() {
  function test_avg_pool2d_complex_dont_include_pad (line 62) | fn test_avg_pool2d_complex_dont_include_pad() {
  type AvgPool2dTestCase (line 88) | struct AvgPool2dTestCase {
    method assert_output (line 103) | fn assert_output(self, x_grad: TestTensor<4>) {

FILE: crates/burn-backend-tests/tests/autodiff/backward.rs
  function test_embedding_backward (line 5) | fn test_embedding_backward() {

FILE: crates/burn-backend-tests/tests/autodiff/bridge.rs
  function test_full_precision (line 5) | fn test_full_precision() {

FILE: crates/burn-backend-tests/tests/autodiff/broadcast.rs
  function mul_broadcast (line 4) | fn mul_broadcast() {
  function div_broadcast (line 9) | fn div_broadcast() {
  function sub_broadcast (line 14) | fn sub_broadcast() {
  function add_broadcast (line 19) | fn add_broadcast() {
  function matmul_broadcast (line 24) | fn matmul_broadcast() {
  function mask_where_broadcast (line 29) | fn mask_where_broadcast() {
  function test_ops_broadcast_backward (line 36) | fn test_ops_broadcast_backward<F>(func: F)

FILE: crates/burn-backend-tests/tests/autodiff/cast.rs
  function cast_keeps_gradient_flow (line 10) | fn cast_keeps_gradient_flow() {

FILE: crates/burn-backend-tests/tests/autodiff/cat.rs
  function should_diff_cat (line 6) | fn should_diff_cat() {
  function should_diff_cat_more_than_1_dim (line 61) | fn should_diff_cat_more_than_1_dim() {
  function should_slice_grads_correctly_when_some_inputs_not_tracked (line 83) | fn should_slice_grads_correctly_when_some_inputs_not_tracked() {

FILE: crates/burn-backend-tests/tests/autodiff/ceil.rs
  function should_diff_ceil (line 5) | fn should_diff_ceil() {

FILE: crates/burn-backend-tests/tests/autodiff/checkpoint.rs
  function test_autodiff_checkpoint_complicated_computation (line 5) | fn test_autodiff_checkpoint_complicated_computation() {
  function test_autodiff_checkpoint_with_missing_requirement (line 32) | fn test_autodiff_checkpoint_with_missing_requirement() {
  function test_autodiff_checkpoint_with_many_duplicates (line 52) | fn test_autodiff_checkpoint_with_many_duplicates() {
  function test_autodiff_checkpoint_with_long_chain_of_eager_memory_bound (line 76) | fn test_autodiff_checkpoint_with_long_chain_of_eager_memory_bound() {
  function test_autodiff_checkpoint_half_sub_graph_not_tracked (line 100) | fn test_autodiff_checkpoint_half_sub_graph_not_tracked() {
  function test_autodiff_checkpoint_very_complex (line 128) | fn test_autodiff_checkpoint_very_complex() {
  function assert_checkpoint (line 163) | fn assert_checkpoint<const D: usize>(tensor: TestAutodiffTensor<D>) {
  function memory_bound_eager (line 172) | fn memory_bound_eager<const D: usize>(
  function memory_bound_eager_scalar (line 178) | fn memory_bound_eager_scalar<const D: usize>(
  function compute_bound_eager (line 186) | fn compute_bound_eager<const D: usize>(
  function compute_bound_eager_scalar (line 193) | fn compute_bound_eager_scalar<const D: usize>(
  function memory_bound_lazy (line 202) | fn memory_bound_lazy<const D: usize>(
  function compute_bound_lazy (line 210) | fn compute_bound_lazy<const D: usize>(

FILE: crates/burn-backend-tests/tests/autodiff/complex.rs
  function should_diff_full_complex_1 (line 5) | fn should_diff_full_complex_1() {
  function should_diff_full_complex_2 (line 31) | fn should_diff_full_complex_2() {
  function should_diff_full_complex_3 (line 57) | fn should_diff_full_complex_3() {

FILE: crates/burn-backend-tests/tests/autodiff/conv1d.rs
  function test_conv1d_basic (line 5) | fn test_conv1d_basic() {
  function test_conv1d_different_channels (line 39) | fn test_conv1d_different_channels() {
  function test_conv1d_with_padding (line 74) | fn test_conv1d_with_padding() {
  function test_conv1d_with_stride (line 108) | fn test_conv1d_with_stride() {
  function test_conv1d_dilation (line 142) | fn test_conv1d_dilation() {
  function test_conv1d_groups (line 176) | fn test_conv1d_groups() {
  type Conv1dTestCase (line 203) | struct Conv1dTestCase {
    method assert_grads (line 222) | fn assert_grads(self, expected_grads: Grads) {
  type Grads (line 215) | struct Grads {

FILE: crates/burn-backend-tests/tests/autodiff/conv2d.rs
  function test_conv2d_basic (line 5) | fn test_conv2d_basic() {
  function test_conv2d_different_channels (line 76) | fn test_conv2d_different_channels() {
  function test_conv2d_different_kernel_size (line 151) | fn test_conv2d_different_kernel_size() {
  function test_conv2d_different_padding (line 222) | fn test_conv2d_different_padding() {
  function test_conv2d_different_width (line 277) | fn test_conv2d_different_width() {
  function test_conv2d_stride_2 (line 332) | fn test_conv2d_stride_2() {
  function test_conv2d_different_stride (line 391) | fn test_conv2d_different_stride() {
  function test_conv2d_dilation_2 (line 462) | fn test_conv2d_dilation_2() {
  function test_conv2d_different_dilation (line 521) | fn test_conv2d_different_dilation() {
  function test_conv2d_groups (line 580) | fn test_conv2d_groups() {
  function test_conv2d_groups_stride_2 (line 631) | fn test_conv2d_groups_stride_2() {
  function test_conv2d_groups_different_channels (line 694) | fn test_conv2d_groups_different_channels() {
  function test_conv2d_complex (line 753) | fn test_conv2d_complex() {
  function test_conv2d_groups_stride_2_no_pad (line 812) | fn test_conv2d_groups_stride_2_no_pad() {
  type Conv2dTestCase (line 878) | struct Conv2dTestCase {
    method assert_grads (line 902) | fn assert_grads(self, expected_grads: Grads) {
  type Grads (line 895) | struct Grads {

FILE: crates/burn-backend-tests/tests/autodiff/conv3d.rs
  function test_conv3d_basic (line 5) | fn test_conv3d_basic() {
  function test_conv3d_complex (line 225) | fn test_conv3d_complex() {
  function test_conv3d_groups_stride_2_no_pad (line 427) | fn test_conv3d_groups_stride_2_no_pad() {
  type Conv3dTestCase (line 594) | struct Conv3dTestCase {
    method assert_grads (line 623) | fn assert_grads(self, expected_grads: Grads) {
  type Grads (line 616) | struct Grads {

FILE: crates/burn-backend-tests/tests/autodiff/conv_transpose1d.rs
  function test_conv_transpose1d_basic (line 5) | fn test_conv_transpose1d_basic() {
  function test_conv_transpose1d_padding (line 39) | fn test_conv_transpose1d_padding() {
  function test_conv_transpose1d_stride (line 73) | fn test_conv_transpose1d_stride() {
  function test_conv_transpose1d_stride_padding_out (line 107) | fn test_conv_transpose1d_stride_padding_out() {
  function test_conv_transpose1d_dilation (line 141) | fn test_conv_transpose1d_dilation() {
  function test_conv_transpose1d_complex (line 175) | fn test_conv_transpose1d_complex() {
  type ConvTranspose1dTestCase (line 214) | struct ConvTranspose1dTestCase {
    method assert_grads (line 233) | fn assert_grads(self, expected_grads: Grads) {
  type Grads (line 226) | struct Grads {

FILE: crates/burn-backend-tests/tests/autodiff/conv_transpose2d.rs
  function test_conv_transpose2d_basic (line 5) | fn test_conv_transpose2d_basic() {
  function test_conv_transpose2d_padding (line 79) | fn test_conv_transpose2d_padding() {
  function test_conv_transpose2d_stride (line 112) | fn test_conv_transpose2d_stride() {
  function test_conv_transpose2d_stride_padding_out (line 145) | fn test_conv_transpose2d_stride_padding_out() {
  function test_conv_transpose2d_dilation (line 178) | fn test_conv_transpose2d_dilation() {
  function test_conv_transpose2d_channels (line 211) | fn test_conv_transpose2d_channels() {
  function test_conv_transpose2d_kernel_size (line 263) | fn test_conv_transpose2d_kernel_size() {
  function test_conv_transpose2d_groups (line 302) | fn test_conv_transpose2d_groups() {
  function test_conv_transpose2d_complex_no_groups (line 346) | fn test_conv_transpose2d_complex_no_groups() {
  function test_conv_transpose2d_complex_no_groups_2 (line 446) | fn test_conv_transpose2d_complex_no_groups_2() {
  function test_conv_transpose2d_complex_groups (line 540) | fn test_conv_transpose2d_complex_groups() {
  type ConvTranspose2dTestCase (line 621) | struct ConvTranspose2dTestCase {
    method assert_grads (line 640) | fn assert_grads(self, expected_grads: Grads) {
  type Grads (line 633) | struct Grads {

FILE: crates/burn-backend-tests/tests/autodiff/conv_transpose3d.rs
  function test_conv_transpose3d_basic (line 5) | fn test_conv_transpose3d_basic() {
  function test_conv_transpose3d_complex_groups (line 215) | fn test_conv_transpose3d_complex_groups() {
  type ConvTranspose3dTestCase (line 622) | struct ConvTranspose3dTestCase {
    method assert_grads (line 641) | fn assert_grads(self, expected_grads: Grads) {
  type Grads (line 634) | struct Grads {

FILE: crates/burn-backend-tests/tests/autodiff/cross.rs
  function backward_basic (line 8) | fn backward_basic() {
  function backward_after_sum (line 38) | fn backward_after_sum() {
  function different_dim (line 68) | fn different_dim() {

FILE: crates/burn-backend-tests/tests/autodiff/cross_entropy.rs
  function test_cross_entropy_loss_grad (line 5) | fn test_cross_entropy_loss_grad() {

FILE: crates/burn-backend-tests/tests/autodiff/cummax.rs
  function should_diff_cummax (line 5) | fn should_diff_cummax() {
  function should_diff_cummax_2d (line 22) | fn should_diff_cummax_2d() {
  function should_diff_cummax_duplicate_values (line 42) | fn should_diff_cummax_duplicate_values() {
  function should_diff_cummax_all_same (line 63) | fn should_diff_cummax_all_same() {
  function should_diff_cummax_increasing (line 81) | fn should_diff_cummax_increasing() {
  function should_diff_cummax_2d_duplicates (line 100) | fn should_diff_cummax_2d_duplicates() {

FILE: crates/burn-backend-tests/tests/autodiff/cummin.rs
  function should_diff_cummin (line 5) | fn should_diff_cummin() {
  function should_diff_cummin_2d (line 22) | fn should_diff_cummin_2d() {
  function should_diff_cummin_duplicate_values (line 42) | fn should_diff_cummin_duplicate_values() {
  function should_diff_cummin_all_same (line 63) | fn should_diff_cummin_all_same() {
  function should_diff_cummin_decreasing (line 81) | fn should_diff_cummin_decreasing() {
  function should_diff_cummin_2d_duplicates (line 100) | fn should_diff_cummin_2d_duplicates() {

FILE: crates/burn-backend-tests/tests/autodiff/cumprod.rs
  function should_diff_cumprod (line 5) | fn should_diff_cumprod() {
  function should_diff_cumprod_2d (line 22) | fn should_diff_cumprod_2d() {
  function should_diff_cumprod_zero_in_middle (line 60) | fn should_diff_cumprod_zero_in_middle() {
  function should_diff_cumprod_zero_at_start (line 79) | fn should_diff_cumprod_zero_at_start() {
  function should_diff_cumprod_zero_at_end (line 98) | fn should_diff_cumprod_zero_at_end() {
  function should_diff_cumprod_multiple_zeros (line 117) | fn should_diff_cumprod_multiple_zeros() {

FILE: crates/burn-backend-tests/tests/autodiff/cumsum.rs
  function should_diff_cumsum_dim0 (line 5) | fn should_diff_cumsum_dim0() {
  function should_diff_cumsum_dim1 (line 34) | fn should_diff_cumsum_dim1() {
  function should_diff_cumsum_complex (line 63) | fn should_diff_cumsum_complex() {

FILE: crates/burn-backend-tests/tests/autodiff/deform_conv2d.rs
  function test_deform_conv2d_basic (line 6) | fn test_deform_conv2d_basic() {
  function test_deform_conv2d_batched (line 127) | fn test_deform_conv2d_batched() {
  function test_deform_conv2d_different_kernel_size (line 300) | fn test_deform_conv2d_different_kernel_size() {
  function test_deform_conv2d_different_padding (line 598) | fn test_deform_conv2d_different_padding() {
  type Conv2dTestCase (line 1653) | struct Conv2dTestCase {
    method assert_grads (line 1680) | fn assert_grads(self, expected_grads: Grads) {
  type Grads (line 1671) | struct Grads {

FILE: crates/burn-backend-tests/tests/autodiff/div.rs
  function should_diff_div (line 5) | fn should_diff_div() {
  function should_diff_div_scalar (line 31) | fn should_diff_div_scalar() {
  function test_div_complex_1 (line 45) | fn test_div_complex_1() {
  function test_div_complex_2 (line 80) | fn test_div_complex_2() {

FILE: crates/burn-backend-tests/tests/autodiff/erf.rs
  function should_diff_erf (line 5) | fn should_diff_erf() {

FILE: crates/burn-backend-tests/tests/autodiff/exp.rs
  function should_diff_exp (line 5) | fn should_diff_exp() {

FILE: crates/burn-backend-tests/tests/autodiff/expand.rs
  function should_diff_expand (line 5) | fn should_diff_expand() {

FILE: crates/burn-backend-tests/tests/autodiff/flip.rs
  function should_diff_flip (line 6) | fn should_diff_flip() {

FILE: crates/burn-backend-tests/tests/autodiff/floor.rs
  function should_diff_floor (line 5) | fn should_diff_floor() {

FILE: crates/burn-backend-tests/tests/autodiff/gather_scatter.rs
  function test_gather_grad (line 5) | fn test_gather_grad() {
  function test_scatter_grad (line 32) | fn test_scatter_grad() {
  function test_scatter_add_grad_partial_indices (line 70) | fn test_scatter_add_grad_partial_indices() {

FILE: crates/burn-backend-tests/tests/autodiff/gelu.rs
  function should_diff_gelu (line 5) | fn should_diff_gelu() {

FILE: crates/burn-backend-tests/tests/autodiff/gradients.rs
  function should_update_tensor_when_grad_replace (line 5) | fn should_update_tensor_when_grad_replace() {

FILE: crates/burn-backend-tests/tests/autodiff/log.rs
  function should_diff_log (line 5) | fn should_diff_log() {

FILE: crates/burn-backend-tests/tests/autodiff/log1p.rs
  function should_diff_log1p (line 6) | fn should_diff_log1p() {

FILE: crates/burn-backend-tests/tests/autodiff/log_sigmoid.rs
  function should_diff_log_sigmoid (line 6) | fn should_diff_log_sigmoid() {

FILE: crates/burn-backend-tests/tests/autodiff/mask.rs
  function should_diff_mask_fill (line 6) | fn should_diff_mask_fill() {
  function should_diff_mask_where (line 32) | fn should_diff_mask_where() {

FILE: crates/burn-backend-tests/tests/autodiff/matmul.rs
  function should_diff_matmul (line 5) | fn should_diff_matmul() {
  function test_matmul_complex_1 (line 31) | fn test_matmul_complex_1() {
  function test_matmul_complex_2 (line 58) | fn test_matmul_complex_2() {

FILE: crates/burn-backend-tests/tests/autodiff/maxmin.rs
  function should_diff_max_dim (line 6) | fn should_diff_max_dim() {
  function should_diff_min_dim (line 32) | fn should_diff_min_dim() {
  function should_diff_min_dim_3d_dim1 (line 58) | fn should_diff_min_dim_3d_dim1() {

FILE: crates/burn-backend-tests/tests/autodiff/maxpool1d.rs
  function test_max_pool1d_simple (line 6) | fn test_max_pool1d_simple() {
  function test_max_pool1d_with_dilation (line 32) | fn test_max_pool1d_with_dilation() {
  function test_max_pool1d_complex (line 67) | fn test_max_pool1d_complex() {
  function test_max_pool1d_complex_with_padding (line 102) | fn test_max_pool1d_complex_with_padding() {

FILE: crates/burn-backend-tests/tests/autodiff/maxpool2d.rs
  function test_max_pool2d_simple_1 (line 6) | fn test_max_pool2d_simple_1() {
  function test_max_pool2d_simple_2 (line 55) | fn test_max_pool2d_simple_2() {
  function test_max_pool2d_with_dilation (line 104) | fn test_max_pool2d_with_dilation() {
  function test_max_pool2d_complex (line 153) | fn test_max_pool2d_complex() {
  function test_max_pool2d_ceil_mode (line 204) | fn test_max_pool2d_ceil_mode() {

FILE: crates/burn-backend-tests/tests/autodiff/memory_management.rs
  function test_mm_independent_trees (line 5) | fn test_mm_independent_trees() {
  function test_mm_crossover_trees_root_unavailable (line 40) | fn test_mm_crossover_trees_root_unavailable() {
  function test_mm_crossover_trees_with_referred_subtree (line 66) | fn test_mm_crossover_trees_with_referred_subtree() {
  function test_mm_three_crossover_trees_last_still_usable (line 92) | fn test_mm_three_crossover_trees_last_still_usable() {
  function test_mm_three_crossover_trees_middle_one_unavailable (line 125) | fn test_mm_three_crossover_trees_middle_one_unavailable() {
  function test_mm_self_referencing_tree (line 157) | fn test_mm_self_referencing_tree() {
  function test_mm_with_non_impacting_detach (line 174) | fn test_mm_with_non_impacting_detach() {
  function test_mm_with_missing_require_grad_after_cleanup (line 191) | fn test_mm_with_missing_require_grad_after_cleanup() {
  function test_mm_with_detach_after_cleanup (line 215) | fn test_mm_with_detach_after_cleanup() {
  function test_mm_deletables_propagate_well (line 242) | fn test_mm_deletables_propagate_well() {
  function test_mm_node_explored_once_can_still_be_tagged_as_useful_when_found_again_deeper (line 263) | fn test_mm_node_explored_once_can_still_be_tagged_as_useful_when_found_a...

FILE: crates/burn-backend-tests/tests/autodiff/mul.rs
  function should_diff_mul (line 5) | fn should_diff_mul() {
  function should_diff_mul_scalar (line 26) | fn should_diff_mul_scalar() {
  function test_mul_complex_1 (line 43) | fn test_mul_complex_1() {

FILE: crates/burn-backend-tests/tests/autodiff/multithread.rs
  function should_behave_the_same_with_multithread (line 5) | fn should_behave_the_same_with_multithread() {

FILE: crates/burn-backend-tests/tests/autodiff/nearest_interpolate.rs
  function test_upsample_interpolation (line 8) | fn test_upsample_interpolation() {
  function test_downsample_interpolation (line 41) | fn test_downsample_interpolation() {
  type InterpolateTestCase (line 63) | struct InterpolateTestCase {
    method assert_output (line 73) | fn assert_output(self, x_grad: TestTensor<4>) {

FILE: crates/burn-backend-tests/tests/autodiff/neg.rs
  function should_diff_neg (line 5) | fn should_diff_neg() {

FILE: crates/burn-backend-tests/tests/autodiff/nonzero.rs
  function should_diff_nonzero (line 5) | fn should_diff_nonzero() {

FILE: crates/burn-backend-tests/tests/autodiff/permute.rs
  function should_diff_permute (line 6) | fn should_diff_permute() {

FILE: crates/burn-backend-tests/tests/autodiff/pow.rs
  function should_diff_powf_scalar (line 6) | fn should_diff_powf_scalar() {
  function should_diff_powf (line 34) | fn should_diff_powf() {
  function should_diff_powf_with_untracked_lhs (line 62) | fn should_diff_powf_with_untracked_lhs() {
  function should_diff_powf_with_untracked_rhs (line 79) | fn should_diff_powf_with_untracked_rhs() {

FILE: crates/burn-backend-tests/tests/autodiff/recip.rs
  function should_diff_recip (line 6) | fn should_diff_recip() {

FILE: crates/burn-backend-tests/tests/autodiff/relu.rs
  function should_diff_relu (line 5) | fn should_diff_relu() {

FILE: crates/burn-backend-tests/tests/autodiff/remainder.rs
  function should_diff_remainder (line 6) | fn should_diff_remainder() {

FILE: crates/burn-backend-tests/tests/autodiff/repeat_dim.rs
  function should_diff_repeat (line 5) | fn should_diff_repeat() {
  function should_diff_repeat_multi_dim (line 26) | fn should_diff_repeat_multi_dim() {

FILE: crates/burn-backend-tests/tests/autodiff/reshape.rs
  function should_diff_reshape (line 5) | fn should_diff_reshape() {

FILE: crates/burn-backend-tests/tests/autodiff/round.rs
  function should_diff_round (line 5) | fn should_diff_round() {

FILE: crates/burn-backend-tests/tests/autodiff/select.rs
  function test_select_grad (line 5) | fn test_select_grad() {
  function test_select_add_grad (line 30) | fn test_select_add_grad() {
  function test_select_add_grad_different_shapes (line 67) | fn test_select_add_grad_different_shapes() {

FILE: crates/burn-backend-tests/tests/autodiff/sigmoid.rs
  function should_diff_sigmoid (line 6) | fn should_diff_sigmoid() {
  function small_neg_val_should_not_cause_grad_overflow (line 22) | fn small_neg_val_should_not_cause_grad_overflow() {

FILE: crates/burn-backend-tests/tests/autodiff/sign.rs
  function should_diff_sign (line 26) | fn should_diff_sign() {

FILE: crates/burn-backend-tests/tests/autodiff/slice.rs
  function should_diff_matmul_with_slice (line 5) | fn should_diff_matmul_with_slice() {
  function should_diff_matmul_with_slice_stepped (line 30) | fn should_diff_matmul_with_slice_stepped() {
  function should_panic_on_slice_with_step (line 58) | fn should_panic_on_slice_with_step() {

FILE: crates/burn-backend-tests/tests/autodiff/slice_assign.rs
  function should_diff_matmul_with_slice_assign (line 6) | fn should_diff_matmul_with_slice_assign() {
  function should_diff_matmul_with_slice_assign_complex (line 34) | fn should_diff_matmul_with_slice_assign_complex() {
  function slice_assign_diff_should_give_same_results_as_cat (line 68) | fn slice_assign_diff_should_give_same_results_as_cat() {
  function should_diff_slice_assign_with_step (line 107) | fn should_diff_slice_assign_with_step() {
  function should_diff_slice_assign_with_negative_step (line 136) | fn should_diff_slice_assign_with_negative_step() {

FILE: crates/burn-backend-tests/tests/autodiff/softmax.rs
  function test_softmax_grad (line 6) | fn test_softmax_grad() {
  function test_log_softmax_grad (line 33) | fn test_log_softmax_grad() {
  function test_quiet_softmax_grad (line 63) | fn test_quiet_softmax_grad() {

FILE: crates/burn-backend-tests/tests/autodiff/sort.rs
  function should_diff_sort (line 6) | fn should_diff_sort() {
  function should_diff_sort_with_indices (line 32) | fn should_diff_sort_with_indices() {
  function should_diff_sort_3d_dim1 (line 59) | fn should_diff_sort_3d_dim1() {

FILE: crates/burn-backend-tests/tests/autodiff/sqrt.rs
  function should_diff_sqrt (line 6) | fn should_diff_sqrt() {

FILE: crates/burn-backend-tests/tests/autodiff/sub.rs
  function should_diff_sub (line 5) | fn should_diff_sub() {
  function should_diff_sub_scalar (line 32) | fn should_diff_sub_scalar() {
  function test_sub_complex_1 (line 48) | fn test_sub_complex_1() {

FILE: crates/burn-backend-tests/tests/autodiff/transpose.rs
  function should_diff_transpose (line 6) | fn should_diff_transpose() {
  function should_diff_swap_dims (line 32) | fn should_diff_swap_dims() {

FILE: crates/burn-backend-tests/tests/autodiff/trig.rs
  function should_diff_cos (line 6) | fn should_diff_cos() {
  function should_diff_sin (line 36) | fn should_diff_sin() {
  function should_diff_tanh (line 66) | fn should_diff_tanh() {
  function should_diff_cosh (line 94) | fn should_diff_cosh() {
  function should_diff_sinh (line 121) | fn should_diff_sinh() {
  function should_diff_tan (line 148) | fn should_diff_tan() {
  function should_diff_asin (line 175) | fn should_diff_asin() {
  function should_diff_acos (line 202) | fn should_diff_acos() {
  function should_diff_atan (line 229) | fn should_diff_atan() {
  function should_diff_asinh (line 256) | fn should_diff_asinh() {
  function should_diff_acosh (line 283) | fn should_diff_acosh() {
  function should_diff_atanh (line 310) | fn should_diff_atanh() {
  function should_diff_atan2 (line 337) | fn should_diff_atan2() {

FILE: crates/burn-backend-tests/tests/autodiff/unfold.rs
  function unfold_backward_accumulates_overlaps (line 5) | fn unfold_backward_accumulates_overlaps() {

FILE: crates/burn-backend-tests/tests/common/autodiff.rs
  type TestAutodiffBackend (line 13) | pub type TestAutodiffBackend = Autodiff<TestBackend, BalancedCheckpointi...
  type TestAutodiffTensor (line 14) | pub type TestAutodiffTensor<const D: usize> = Tensor<TestAutodiffBackend...

FILE: crates/burn-backend-tests/tests/common/backend.rs
  type TestBackend (line 6) | pub type TestBackend = burn_ndarray::NdArray<FloatElemType>;
  type TestBackend (line 9) | pub type TestBackend = burn_tch::LibTorch<FloatElemType>;
  type TestBackend (line 12) | pub type TestBackend = burn_cuda::Cuda<FloatElemType, super::IntElemType>;
  type TestBackend (line 15) | pub type TestBackend = burn_rocm::Rocm<FloatElemType, super::IntElemType>;
  type TestBackend (line 18) | pub type TestBackend = burn_wgpu::Wgpu<FloatElemType, super::IntElemType>;
  type TestBackend (line 21) | pub type TestBackend = burn_cpu::Cpu<FloatElemType, super::IntElemType>;
  type TestBackend (line 24) | pub type TestBackend = burn_router::BackendRouter<
  type TestTensor (line 35) | pub type TestTensor<const D: usize> = Tensor<TestBackend, D>;
  type TestTensorInt (line 36) | pub type TestTensorInt<const D: usize> = Tensor<TestBackend, D, burn_ten...
  type TestTensorBool (line 37) | pub type TestTensorBool<const D: usize> = Tensor<TestBackend, D, burn_te...
  type FloatElem (line 39) | pub type FloatElem = burn_tensor::ops::FloatElem<TestBackend>;
  type IntElem (line 40) | pub type IntElem = burn_tensor::ops::IntElem<TestBackend>;
  type TestAutodiffBackend (line 42) | pub type TestAutodiffBackend = Autodiff<TestBackend>;
  type TestAutodiffTensor (line 43) | pub type TestAutodiffTensor<const D: usize> = Tensor<TestAutodiffBackend...

FILE: crates/burn-backend-tests/tests/cubecl.rs
  type FloatElemType (line 6) | type FloatElemType = f32;
  type IntElemType (line 7) | type IntElemType = i32;
  type ReferenceBackend (line 11) | pub type ReferenceBackend = burn_ndarray::NdArray<FloatElemType>;

FILE: crates/burn-backend-tests/tests/cubecl/avg_pool2d.rs
  function avg_pool2d_should_match_reference_backend (line 8) | fn avg_pool2d_should_match_reference_backend() {
  function avg_pool2d_backward_should_match_reference_backend (line 44) | fn avg_pool2d_backward_should_match_reference_backend() {

FILE: crates/burn-backend-tests/tests/cubecl/bernoulli.rs
  function number_of_1_proportional_to_prob (line 13) | fn number_of_1_proportional_to_prob() {
  function wald_wolfowitz_runs_test (line 33) | fn wald_wolfowitz_runs_test() {

FILE: crates/burn-backend-tests/tests/cubecl/cast.rs
  function should_cast_int_to_float (line 5) | fn should_cast_int_to_float() {
  function should_cast_bool_to_int (line 24) | fn should_cast_bool_to_int() {
  function should_cast_bool_to_float (line 36) | fn should_cast_bool_to_float() {

FILE: crates/burn-backend-tests/tests/cubecl/cat.rs
  function cat_should_match_reference_backend_dim0 (line 6) | fn cat_should_match_reference_backend_dim0() {
  function cat_should_match_reference_backend_dim1 (line 11) | fn cat_should_match_reference_backend_dim1() {
  function cat_should_support_uneven_launch (line 16) | fn cat_should_support_uneven_launch() {
  function test_same_as_reference (line 20) | fn test_same_as_reference(shape: [usize; 2], num_tensors: usize, dim: us...

FILE: crates/burn-backend-tests/tests/cubecl/clamp.rs
  function clamp_should_match_reference (line 6) | fn clamp_should_match_reference() {

FILE: crates/burn-backend-tests/tests/cubecl/contiguous.rs
  function into_contiguous_match_reference_backend_1 (line 6) | pub fn into_contiguous_match_reference_backend_1() {
  function get_combinations (line 33) | fn get_combinations(n: usize) -> impl Iterator<Item = (usize, usize)> {

FILE: crates/burn-backend-tests/tests/cubecl/conv2d.rs
  function conv2d_should_match_reference_backend (line 7) | fn conv2d_should_match_reference_backend() {
  function conv2d_should_match_reference_backend_implicit (line 31) | fn conv2d_should_match_reference_backend_implicit() {
  function conv2d_should_match_reference_backend_bias_regression (line 57) | fn conv2d_should_match_reference_backend_bias_regression() {
  function conv2d_weight_backward_should_run (line 82) | fn conv2d_weight_backward_should_run() {

FILE: crates/burn-backend-tests/tests/cubecl/conv3d.rs
  function conv3d_should_match_reference_backend (line 6) | fn conv3d_should_match_reference_backend() {

FILE: crates/burn-backend-tests/tests/cubecl/conv_transpose2d.rs
  function conv_transpose2d_should_match_reference_backend (line 6) | fn conv_transpose2d_should_match_reference_backend() {

FILE: crates/burn-backend-tests/tests/cubecl/conv_transpose3d.rs
  function conv_transpose3d_should_match_reference_backend (line 6) | fn conv_transpose3d_should_match_reference_backend() {

FILE: crates/burn-backend-tests/tests/cubecl/cross.rs
  function test_cross_product (line 6) | fn test_cross_product() {
  function test_cross_product_zeros (line 26) | fn test_cross_product_zeros() {
  function test_cross_product_batch (line 43) | fn test_cross_product_batch() {
  function test_cross_product_invalid_dimension (line 64) | fn test_cross_product_invalid_dimension() {
  function test_cross_product_parallel_vectors (line 73) | fn test_cross_product_parallel_vectors() {
  function test_cross_product_3d_tensor (line 89) | fn test_cross_product_3d_tensor() {
  function test_cross_product_with_padding_awareness (line 125) | fn test_cross_product_with_padding_awareness() {

FILE: crates/burn-backend-tests/tests/cubecl/gather.rs
  function gather_should_work_with_multiple_workgroups_dim0 (line 6) | fn gather_should_work_with_multiple_workgroups_dim0() {
  function gather_should_work_with_multiple_workgroups_dim1 (line 11) | fn gather_should_work_with_multiple_workgroups_dim1() {
  function test_same_as_ref (line 15) | fn test_same_as_ref<const D: usize>(shape: [usize; D], dim: usize) {

FILE: crates/burn-backend-tests/tests/cubecl/mask_fill.rs
  function mask_fill_should_match_reference_backend (line 8) | fn mask_fill_should_match_reference_backend() {
  function mask_fill_inplace_should_match_reference_backend (line 28) | fn mask_fill_inplace_should_match_reference_backend() {
  function inputs_mask_fill (line 48) | fn inputs_mask_fill() -> (

FILE: crates/burn-backend-tests/tests/cubecl/mask_where.rs
  function mask_where_should_match_reference_backend (line 7) | fn mask_where_should_match_reference_backend() {
  function mask_where_inplace_lhs_should_match_reference_backend (line 18) | fn mask_where_inplace_lhs_should_match_reference_backend() {
  function mask_where_inplace_rhs_should_match_reference_backend (line 37) | fn mask_where_inplace_rhs_should_match_reference_backend() {
  function inputs_mask_where (line 56) | fn inputs_mask_where() -> (

FILE: crates/burn-backend-tests/tests/cubecl/max_pool2d.rs
  function max_pool2d_should_match_reference_backends (line 6) | pub fn max_pool2d_should_match_reference_backends() {
  function max_pool2d_with_indices_should_match_reference_backend (line 28) | pub fn max_pool2d_with_indices_should_match_reference_backend() {

FILE: crates/burn-backend-tests/tests/cubecl/max_pool2d_backward.rs
  function max_pool2d_with_indices_backward_should_match_reference_backend (line 6) | pub fn max_pool2d_with_indices_backward_should_match_reference_backend() {

FILE: crates/burn-backend-tests/tests/cubecl/normal.rs
  function empirical_mean_close_to_expectation (line 8) | fn empirical_mean_close_to_expectation() {
  function normal_respects_68_95_99_rule (line 23) | fn normal_respects_68_95_99_rule() {

FILE: crates/burn-backend-tests/tests/cubecl/quantization.rs
  function should_quantize_dequantize_symmetric_arange (line 9) | fn should_quantize_dequantize_symmetric_arange<S: Into<Shape>>(
  function should_quantize_dequantize_symmetric_per_block_arange (line 39) | fn should_quantize_dequantize_symmetric_per_block_arange<S: Into<Shape>>(
  function should_quantize_dequantize_symmetric_per_block (line 71) | fn should_quantize_dequantize_symmetric_per_block(
  function supports_native (line 110) | fn supports_native() -> bool {
  function should_quantize_dequantize_symmetric_arange_q8s_packed (line 123) | fn should_quantize_dequantize_symmetric_arange_q8s_packed() {
  function should_quantize_dequantize_symmetric_arange_q8f_packed (line 128) | fn should_quantize_dequantize_symmetric_arange_q8f_packed() {
  function should_quantize_dequantize_symmetric_arange_q4s_packed (line 133) | fn should_quantize_dequantize_symmetric_arange_q4s_packed() {
  function should_quantize_dequantize_symmetric_arange_q4f_packed (line 138) | fn should_quantize_dequantize_symmetric_arange_q4f_packed() {
  function should_quantize_dequantize_symmetric_arange_q2s_packed (line 143) | fn should_quantize_dequantize_symmetric_arange_q2s_packed() {
  function should_quantize_dequantize_symmetric_arange_q2f_packed (line 148) | fn should_quantize_dequantize_symmetric_arange_q2f_packed() {
  function should_quantize_dequantize_symmetric_per_block_q8s_packed (line 153) | fn should_quantize_dequantize_symmetric_per_block_q8s_packed() {
  function should_quantize_dequantize_symmetric_per_block_q4s_packed (line 158) | fn should_quantize_dequantize_symmetric_per_block_q4s_packed() {
  function should_panic_when_block_size_cannot_store_num_quants (line 164) | fn should_panic_when_block_size_cannot_store_num_quants() {
  function should_quantize_dequantize_symmetric_per_block_q2s_packed (line 170) | fn should_quantize_dequantize_symmetric_per_block_q2s_packed() {
  function should_quantize_dequantize_symmetric_arange_q8s_native (line 175) | fn should_quantize_dequantize_symmetric_arange_q8s_native() {
  function should_quantize_dequantize_symmetric_per_block_q8s_native (line 182) | fn should_quantize_dequantize_symmetric_per_block_q8s_native() {
  function should_quantize_dequantize_symmetric_per_block_arange_q8s_packed (line 189) | fn should_quantize_dequantize_symmetric_per_block_arange_q8s_packed() {
  function should_quantize_dequantize_symmetric_per_block_arange_q8s_native (line 199) | fn should_quantize_dequantize_symmetric_per_block_arange_q8s_native() {
  function should_quantize_dequantize_symmetric_arange_128x256_q8s_native (line 211) | fn should_quantize_dequantize_symmetric_arange_128x256_q8s_native() {
  function should_quantize_dequantize_symmetric_arange_128x256_q8s_packed (line 222) | fn should_quantize_dequantize_symmetric_arange_128x256_q8s_packed() {
  function should_panic_when_shape_cannot_store_quants (line 233) | fn should_panic_when_shape_cannot_store_quants() {

FILE: crates/burn-backend-tests/tests/cubecl/reduce.rs
  constant RANK (line 5) | const RANK: usize = 4;
  constant SHAPE (line 6) | const SHAPE: [usize; RANK] = [2, 4, 8, 16];
  function reduction_argmax_should_match_reference_backend (line 9) | fn reduction_argmax_should_match_reference_backend() {
  function reduction_argmin_should_match_reference_backend (line 24) | fn reduction_argmin_should_match_reference_backend() {
  function reduction_mean_dim_should_match_reference_backend (line 39) | fn reduction_mean_dim_should_match_reference_backend() {
  function reduction_mean_should_match_reference_backend (line 57) | fn reduction_mean_should_match_reference_backend() {
  function reduction_prod_dim_should_match_reference_backend (line 73) | fn reduction_prod_dim_should_match_reference_backend() {
  function reduction_prod_should_match_reference_backend (line 91) | fn reduction_prod_should_match_reference_backend() {
  function reduction_sum_dim_should_match_reference_backend (line 107) | fn reduction_sum_dim_should_match_reference_backend() {
  function reduction_sum_should_match_reference_backend (line 125) | fn reduction_sum_should_match_reference_backend() {
  function reduction_sum_should_match_reference_backend_64bit (line 139) | fn reduction_sum_should_match_reference_backend_64bit() {

FILE: crates/burn-backend-tests/tests/cubecl/repeat_dim.rs
  function repeat_dim_0_few_times (line 6) | fn repeat_dim_0_few_times() {
  function repeat_dim_1_few_times (line 23) | fn repeat_dim_1_few_times() {
  function repeat_dim_2_few_times (line 40) | fn repeat_dim_2_few_times() {
  function repeat_dim_2_many_times (line 57) | fn repeat_dim_2_many_times() {

FILE: crates/burn-backend-tests/tests/cubecl/scatter.rs
  function scatter_should_work_with_multiple_workgroups_2d_dim0 (line 6) | fn scatter_should_work_with_multiple_workgroups_2d_dim0() {
  function scatter_should_work_with_multiple_workgroups_2d_dim1 (line 11) | fn scatter_should_work_with_multiple_workgroups_2d_dim1() {
  function scatter_should_work_with_multiple_workgroups_3d_dim0 (line 16) | fn scatter_should_work_with_multiple_workgroups_3d_dim0() {
  function scatter_should_work_with_multiple_workgroups_3d_dim1 (line 21) | fn scatter_should_work_with_multiple_workgroups_3d_dim1() {
  function scatter_should_work_with_multiple_workgroups_3d_dim2 (line 26) | fn scatter_should_work_with_multiple_workgroups_3d_dim2() {
  function scatter_should_work_with_multiple_workgroups_diff_shapes (line 31) | fn scatter_should_work_with_multiple_workgroups_diff_shapes() {
  function same_as_reference_diff_shape (line 35) | fn same_as_reference_diff_shape<const D: usize>(
  function same_as_reference_same_shape (line 64) | fn same_as_reference_same_shape<const D: usize>(dim: usize, shape: [usiz...

FILE: crates/burn-backend-tests/tests/cubecl/select.rs
  function select_should_work_with_multiple_workgroups (line 6) | fn select_should_work_with_multiple_workgroups() {

FILE: crates/burn-backend-tests/tests/cubecl/select_assign.rs
  function select_add_should_work_with_multiple_workgroups_2d_dim0 (line 6) | fn select_add_should_work_with_multiple_workgroups_2d_dim0() {
  function select_add_should_work_with_multiple_workgroups_2d_dim1 (line 11) | fn select_add_should_work_with_multiple_workgroups_2d_dim1() {
  function select_add_should_work_with_multiple_workgroups_3d_dim0 (line 16) | fn select_add_should_work_with_multiple_workgroups_3d_dim0() {
  function select_add_should_work_with_multiple_workgroups_3d_dim1 (line 21) | fn select_add_should_work_with_multiple_workgroups_3d_dim1() {
  function select_add_should_work_with_multiple_workgroups_3d_dim2 (line 26) | fn select_add_should_work_with_multiple_workgroups_3d_dim2() {
  function select_add_same_as_ref (line 30) | fn select_add_same_as_ref<const D: usize>(dim: usize, shape: [usize; D]) {

FILE: crates/burn-backend-tests/tests/cubecl/slice.rs
  function slice_should_work_with_multiple_workgroups (line 6) | fn slice_should_work_with_multiple_workgroups() {

FILE: crates/burn-backend-tests/tests/cubecl/slice_assign.rs
  function slice_assign_should_work_with_multiple_workgroups (line 5) | fn slice_assign_should_work_with_multiple_workgroups() {

FILE: crates/burn-backend-tests/tests/cubecl/unary.rs
  function tanh_should_not_have_numerical_bugs_on_macos (line 5) | fn tanh_should_not_have_numerical_bugs_on_macos() {

FILE: crates/burn-backend-tests/tests/cubecl/uniform.rs
  function values_all_within_interval_default (line 11) | fn values_all_within_interval_default() {
  function values_all_within_interval_uniform (line 24) | fn values_all_within_interval_uniform() {
  function at_least_one_value_per_bin_uniform (line 37) | fn at_least_one_value_per_bin_uniform() {
  function runs_test (line 51) | fn runs_test() {
  function int_values_all_within_interval_uniform (line 65) | fn int_values_all_within_interval_uniform() {
  function at_least_one_value_per_bin_int_uniform (line 78) | fn at_least_one_value_per_bin_int_uniform() {
  function should_not_fail_on_non_float_autotune (line 94) | fn should_not_fail_on_non_float_autotune() {
  function test_seed_reproducibility (line 104) | fn test_seed_reproducibility() {

FILE: crates/burn-backend-tests/tests/fused_ops/reduce_broadcasted.rs
  function test_reduce_broadcasted_1 (line 5) | fn test_reduce_broadcasted_1() {
  function test_reduce_broadcasted_2 (line 38) | fn test_reduce_broadcasted_2() {
  function test_reduce_broadcasted_3 (line 76) | fn test_reduce_broadcasted_3() {
  function test_reduce_broadcasted_4_reused_partial (line 117) | fn test_reduce_broadcasted_4_reused_partial() {

FILE: crates/burn-backend-tests/tests/fusion.rs
  type FloatElemType (line 13) | pub type FloatElemType = f32;
  type IntElemType (line 14) | pub type IntElemType = i32;
  type TestBackend (line 24) | pub type TestBackend = burn_fusion::Fusion<backend::TestBackend>;
  type TestTensor (line 25) | pub type TestTensor<const D: usize> = Tensor<TestBackend, D>;
  type TestTensorInt (line 26) | pub type TestTensorInt<const D: usize> = Tensor<TestBackend, D, burn_ten...
  type TestTensorBool (line 27) | pub type TestTensorBool<const D: usize> = Tensor<TestBackend, D, burn_te...

FILE: crates/burn-backend-tests/tests/tensor.rs
  type FloatElemType (line 6) | pub type FloatElemType = f32;
  type IntElemType (line 8) | pub type IntElemType = i32;

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/all.rs
  function test_all (line 5) | fn test_all() {
  function test_all_dim (line 18) | fn test_all_dim() {
  function test_all_with_bool_from_lower_equal (line 26) | fn test_all_with_bool_from_lower_equal() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/any.rs
  function test_any (line 5) | fn test_any() {
  function test_any_dim (line 18) | fn test_any_dim() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/argwhere_nonzero.rs
  function test_argwhere_1d (line 6) | fn test_argwhere_1d() {
  function test_argwhere_2d (line 16) | fn test_argwhere_2d() {
  function test_argwhere_3d (line 26) | fn test_argwhere_3d() {
  function test_nonzero_1d (line 40) | fn test_nonzero_1d() {
  function test_nonzero_2d (line 53) | fn test_nonzero_2d() {
  function test_nonzero_3d (line 70) | fn test_nonzero_3d() {
  function test_nonzero_empty (line 94) | fn test_nonzero_empty() {
  function test_argwhere_empty (line 102) | fn test_argwhere_empty() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/cat.rs
  function should_support_cat_ops_bool (line 5) | fn should_support_cat_ops_bool() {
  function should_support_cat_with_empty_tensor_bool (line 19) | fn should_support_cat_with_empty_tensor_bool() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/comparison.rs
  function should_support_bool_equal (line 5) | fn should_support_bool_equal() {
  function should_support_bool_not_equal (line 21) | fn should_support_bool_not_equal() {
  function should_support_bool_not (line 37) | fn should_support_bool_not() {
  function test_bool_equal_elem (line 50) | fn test_bool_equal_elem() {
  function test_bool_not_equal_elem (line 62) | fn test_bool_not_equal_elem() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/create_like.rs
  function should_support_zeros_like (line 5) | fn should_support_zeros_like() {
  function should_support_ones_like (line 21) | fn should_support_ones_like() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/expand.rs
  function expand_2d_bool (line 5) | fn expand_2d_bool() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/flip.rs
  function flip_bool (line 5) | fn flip_bool() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/full.rs
  function test_tensor_full (line 5) | fn test_tensor_full() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/gather_scatter.rs
  function should_scatter_1d_bool (line 5) | fn should_scatter_1d_bool() {
  function should_gather_1d_dim0_bool (line 19) | fn should_gather_1d_dim0_bool() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/init.rs
  function should_support_bool_empty (line 5) | fn should_support_bool_empty() {
  function should_support_bool_zeros (line 12) | fn should_support_bool_zeros() {
  function should_support_bool_ones (line 23) | fn should_support_bool_ones() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/logical.rs
  function test_bool_and (line 5) | fn test_bool_and() {
  function test_bool_or (line 14) | fn test_bool_or() {
  function test_bool_xor (line 23) | fn test_bool_xor() {
  function test_bool_or_vec (line 32) | fn test_bool_or_vec() {
  function test_bool_and_vec (line 42) | fn test_bool_and_vec() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/mask.rs
  function should_support_bool_mask_where_ops (line 5) | fn should_support_bool_mask_where_ops() {
  function should_support_bool_mask_fill_ops (line 20) | fn should_support_bool_mask_fill_ops() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/movedim.rs
  function movedim_bool (line 5) | fn movedim_bool() {
  function vec_input_bool (line 32) | fn vec_input_bool() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/permute.rs
  function permute_bool (line 5) | fn permute_bool() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/repeat.rs
  function should_support_bool_repeat_ops_one_dimension (line 5) | fn should_support_bool_repeat_ops_one_dimension() {
  function should_support_bool_repeat_on_many_dimension (line 20) | fn should_support_bool_repeat_on_many_dimension() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/repeat_dim.rs
  function should_support_bool_repeat_ops (line 5) | fn should_support_bool_repeat_ops() {
  function should_support_bool_repeat_on_dims_larger_than_1 (line 20) | fn should_support_bool_repeat_on_dims_larger_than_1() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/reshape.rs
  function should_support_reshape_bool (line 5) | fn should_support_reshape_bool() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/select.rs
  function should_select_bool_tensor_1d (line 5) | fn should_select_bool_tensor_1d() {
  function should_select_bool_tensor_2d (line 18) | fn should_select_bool_tensor_2d() {
  function should_select_add_bool_tensor (line 32) | fn should_select_add_bool_tensor() {
  function should_select_add_bool_overlapping_indices (line 50) | fn should_select_add_bool_overlapping_indices() {
  function should_select_add_bool_false_to_true_case (line 65) | fn should_select_add_bool_false_to_true_case() {
  function should_select_add_bool_true_or_true_accumulation (line 79) | fn should_select_add_bool_true_or_true_accumulation() {
  function should_match_default_implementation_behavior (line 93) | fn should_match_default_implementation_behavior() {
  function should_select_add_bool_overlapping_indices_vs_default (line 117) | fn should_select_add_bool_overlapping_indices_vs_default() {
  function should_select_add_bool_true_or_true_accumulation_vs_default (line 140) | fn should_select_add_bool_true_or_true_accumulation_vs_default() {
  function should_select_add_bool_false_to_true_case_vs_default (line 163) | fn should_select_add_bool_false_to_true_case_vs_default() {
  function should_select_add_bool_tensor_vs_default (line 186) | fn should_select_add_bool_tensor_vs_default() {
  function should_fail_if_replacement_semantics_were_used (line 210) | fn should_fail_if_replacement_semantics_were_used() {
  function should_fail_if_replacement_semantics_were_used_vs_default (line 225) | fn should_fail_if_replacement_semantics_were_used_vs_default() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/stack.rs
  function should_support_stack_ops_bool (line 6) | fn should_support_stack_ops_bool() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/take.rs
  function should_take_bool_tensor (line 5) | fn should_take_bool_tensor() {
  function should_take_bool_tensor_with_2d_indices (line 18) | fn should_take_bool_tensor_with_2d_indices() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/transpose.rs
  function should_support_transpose_bool (line 5) | fn should_support_transpose_bool() {
  function should_support_swap_dims_bool (line 24) | fn should_support_swap_dims_bool() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/tri_mask.rs
  function square_diag (line 5) | fn square_diag() {
  function square_diag_offset (line 17) | fn square_diag_offset() {
  function square_tri_upper (line 26) | fn square_tri_upper() {
  function square_tri_upper_offset (line 38) | fn square_tri_upper_offset() {
  function square_tri_lower (line 50) | fn square_tri_lower() {
  function square_tri_lower_offset (line 63) | fn square_tri_lower_offset() {
  function rect_diag (line 76) | fn rect_diag() {

FILE: crates/burn-backend-tests/tests/tensor/bool/ops/unfold.rs
  function test_unfold_bool (line 6) | fn test_unfold_bool() {

FILE: crates/burn-backend-tests/tests/tensor/clone_invariance.rs
  type CloneInvarianceTest (line 14) | pub trait CloneInvarianceTest<const D: usize> {
    method args (line 17) | fn args(&self) -> Self::Args;
    method run (line 19) | fn run(&self, args: &Self::Args, inplace: bool) -> TensorData;
    method check (line 21) | fn check(&self) {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/celu.rs
  function test_celu_d2 (line 6) | fn test_celu_d2() {
  function test_celu_with_alpha (line 22) | fn test_celu_with_alpha() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/elu.rs
  function test_elu (line 6) | fn test_elu() {
  function test_elu_alpha (line 20) | fn test_elu_alpha() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/gelu.rs
  function test_gelu (line 6) | fn test_gelu() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/glu.rs
  function test_glu_d3 (line 5) | fn test_glu_d3() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/hard_sigmoid.rs
  function test_hard_sigmoid (line 6) | fn test_hard_sigmoid() {
  function test_hard_sigmoid_overflow (line 18) | fn test_hard_sigmoid_overflow() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/leaky_relu.rs
  function test_leaky_relu_d2 (line 6) | fn test_leaky_relu_d2() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/log_sigmoid.rs
  function test_log_sigmoid (line 6) | fn test_log_sigmoid() {
  function test_log_sigmoid_numerical_stability (line 19) | fn test_log_sigmoid_numerical_stability() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/mish.rs
  function test_mish (line 6) | fn test_mish() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/prelu.rs
  function test_prelu_2_dimension (line 6) | fn test_prelu_2_dimension() {
  function test_prelu_2_dimension_scalar_weight (line 23) | fn test_prelu_2_dimension_scalar_weight() {
  function test_prelu_positives (line 41) | fn test_prelu_positives() {
  function test_prelu_zero_weight (line 56) | fn test_prelu_zero_weight() {
  function test_prelu_some_weight (line 69) | fn test_prelu_some_weight() {
  function test_prelu_single_dim_multi_weight (line 82) | fn test_prelu_single_dim_multi_weight() {
  function test_prelu_multi_dim_wrong_weights (line 94) | fn test_prelu_multi_dim_wrong_weights() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/quiet_softmax.rs
  function test_quiet_softmax_d2 (line 6) | fn test_quiet_softmax_d2() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/relu.rs
  function test_relu_d2 (line 5) | fn test_relu_d2() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/selu.rs
  function test_selu (line 6) | fn test_selu() {
  function test_selu_zero (line 28) | fn test_selu_zero() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/sigmoid.rs
  function test_sigmoid (line 6) | fn test_sigmoid() {
  function test_sigmoid_overflow (line 18) | fn test_sigmoid_overflow() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/silu.rs
  function test_silu (line 6) | fn test_silu() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/softmax.rs
  function test_softmax_d2 (line 6) | fn test_softmax_d2() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/softmin.rs
  function test_softmin_d2 (line 6) | fn test_softmin_d2() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/softplus.rs
  function test_softplus_d2 (line 6) | fn test_softplus_d2() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/softsign.rs
  function test_softsign (line 6) | fn test_softsign() {
  function test_softsign_zero (line 18) | fn test_softsign_zero() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/tanh_activation.rs
  function test_tanh (line 6) | fn test_tanh() {

FILE: crates/burn-backend-tests/tests/tensor/float/activation/thresholded_relu.rs
  function test_thresholded_relu_d2 (line 5) | fn test_thresholded_relu_d2() {
  function test_thresholded_relu_d2_alpha (line 17) | fn test_thresholded_relu_d2_alpha() {

FILE: crates/burn-backend-tests/tests/tensor/float/grid/affine_grid.rs
  function create_identity_transform (line 4) | fn create_identity_transform(batch_size: usize) -> TestTensor<3> {
  function test_affine_grid_identity (line 10) | fn test_affine_grid_identity() {
  function test_affine_grid_scaling (line 32) | fn test_affine_grid_scaling() {
  function test_affine_grid_translation (line 53) | fn test_affine_grid_translation() {

FILE: crates/burn-backend-tests/tests/tensor/float/grid/meshgrid.rs
  function assert_tensors_equal (line 10) | fn assert_tensors_equal<const N: usize, B: Backend, K>(
  function test_meshgrid (line 24) | fn test_meshgrid() {
  function test_meshgrid_stack (line 129) | fn test_meshgrid_stack() {

FILE: crates/burn-backend-tests/tests/tensor/float/linalg/cosine_similarity.rs
  function test_cosine_similarity_basic (line 6) | fn test_cosine_similarity_basic() {
  function test_cosine_similarity_orthogonal (line 24) | fn test_cosine_similarity_orthogonal() {
  function test_cosine_similarity_parallel (line 37) | fn test_cosine_similarity_parallel() {
  function test_cosine_similarity_opposite (line 50) | fn test_cosine_similarity_opposite() {
  function test_cosine_similarity_different_dimension (line 63) | fn test_cosine_similarity_different_dimension() {
  function test_cosine_similarity_near_zero (line 85) | fn test_cosine_similarity_near_zero() {

FILE: crates/burn-backend-tests/tests/tensor/float/linalg/diag.rs
  function test_diag_2d_square (line 5) | fn test_diag_2d_square() {
  function test_diag_2d_tall (line 15) | fn test_diag_2d_tall() {
  function test_diag_2d_wide (line 28) | fn test_diag_2d_wide() {
  function test_diag_3d_batch_square (line 40) | fn test_diag_3d_batch_square() {
  function test_diag_3d_batch_tall (line 55) | fn test_diag_3d_batch_tall() {
  function test_diag_3d_batch_wide (line 73) | fn test_diag_3d_batch_wide() {
  function test_diag_4d_batch_channel_square (line 91) | fn test_diag_4d_batch_channel_square() {
  function test_diag_4d_batch_channel_tall (line 109) | fn test_diag_4d_batch_channel_tall() {
  function test_diag_4d_batch_channel_wide (line 127) | fn test_diag_4d_batch_channel_wide() {
  function test_diag_1x1 (line 145) | fn test_diag_1x1() {
  function test_diag_single_row (line 157) | fn test_diag_single_row() {
  function test_diag_single_column (line 169) | fn test_diag_single_column() {
  function test_diag_zeros (line 181) | fn test_diag_zeros() {
  function test_diag_batch_single_element (line 193) | fn test_diag_batch_single_element() {
  function test_diag_batch_mixed_zeros (line 205) | fn test_diag_batch_mixed_zeros() {
  function test_diag_int_tensor (line 220) | fn test_diag_int_tensor() {
  function test_diag_int_3x3 (line 232) | fn test_diag_int_3x3() {
  function test_diag_1d_should_panic (line 245) | fn test_diag_1d_should_panic() {
  function test_diag_wrong_output_rank_should_panic (line 254) | fn test_diag_wrong_output_rank_should_panic() {

FILE: crates/burn-backend-tests/tests/tensor/float/linalg/lu_decomposition.rs
  function test_lu_2x2_decomposition (line 7) | fn test_lu_2x2_decomposition() {
  function test_lu_3x3_decomposition (line 16) | fn test_lu_3x3_decomposition() {
  function test_lu_singular_matrix (line 44) | fn test_lu_singular_matrix() {
  function test_lu_non_square_matrix (line 52) | fn test_lu_non_square_matrix() {
  function test_lu_1x1_element_matrix (line 59) | fn test_lu_1x1_element_matrix() {
  function test_lu_identity_matrix (line 69) | fn test_lu_identity_matrix() {
  function test_lu_50x50_random_matrix (line 79) | fn test_lu_50x50_random_matrix() {

FILE: crates/burn-backend-tests/tests/tensor/float/linalg/matvec.rs
  function test_matvec_basic_float (line 5) | fn test_matvec_basic_float() {
  function test_matvec_basic_int (line 19) | fn test_matvec_basic_int() {
  function test_matvec_batched (line 31) | fn test_matvec_batched() {
  function test_matvec_vector_broadcasts_over_batches (line 51) | fn test_matvec_vector_broadcasts_over_batches() {
  function test_matvec_matrix_broadcasts_over_vector_batches (line 71) | fn test_matvec_matrix_broadcasts_over_vector_batches() {
  function test_matvec_invalid_inner_dim_panics (line 86) | fn test_matvec_invalid_inner_dim_panics() {
  function test_matvec_mismatched_batches_panics (line 96) | fn test_matvec_mismatched_batches_panics() {

FILE: crates/burn-backend-tests/tests/tensor/float/linalg/outer.rs
  function test_outer_basic (line 8) | fn test_outer_basic() {
  function test_outer_shapes_only (line 19) | fn test_outer_shapes_only() {
  function test_outer_asymmetry_and_shapes (line 28) | fn test_outer_asymmetry_and_shapes() {
  function test_outer_zero_left (line 40) | fn test_outer_zero_left() {
  function test_outer_zero_right (line 52) | fn test_outer_zero_right() {
  function test_outer_signs (line 64) | fn test_outer_signs() {
  function test_outer_integer_inputs (line 75) | fn test_outer_integer_inputs() {
  function test_outer_equivalence_to_matmul (line 86) | fn test_outer_equivalence_to_matmul() {
  function test_outer_vector_identity_right_mult (line 100) | fn test_outer_vector_identity_right_mult() {
  function test_outer_length_one_vectors (line 116) | fn test_outer_length_one_vectors() {
  function test_outer_large_values (line 127) | fn test_outer_large_values() {
  function test_outer_nan_propagation (line 140) | fn test_outer_nan_propagation() {
  function test_outer_batched_basic (line 159) | fn test_outer_batched_basic() {
  function test_outer_batched_shapes (line 173) | fn test_outer_batched_shapes() {
  function test_outer_batched_zero_left (line 182) | fn test_outer_batched_zero_left() {
  function test_outer_batched_zero_right (line 193) | fn test_outer_batched_zero_right() {
  function test_outer_batched_signs (line 204) | fn test_outer_batched_signs() {
  function test_outer_batched_equivalence_to_per_sample_outer (line 215) | fn test_outer_batched_equivalence_to_per_sample_outer() {
  function test_outer_batched_mismatched_batches_panics (line 246) | fn test_outer_batched_mismatched_batches_panics() {
  function test_outer_dim (line 254) | fn test_outer_dim() {

FILE: crates/burn-backend-tests/tests/tensor/float/linalg/trace.rs
  function test_trace_2d_square (line 5) | fn test_trace_2d_square() {
  function test_trace_2d_rectangular_wide (line 16) | fn test_trace_2d_rectangular_wide() {
  function test_trace_2d_rectangular_tall (line 26) | fn test_trace_2d_rectangular_tall() {
  function test_trace_3d_batch (line 36) | fn test_trace_3d_batch() {
  function test_trace_4d_batch (line 50) | fn test_trace_4d_batch() {
  function test_trace_single_element (line 69) | fn test_trace_single_element() {
  function test_trace_zeros (line 79) | fn test_trace_zeros() {
  function test_trace_negative_values (line 89) | fn test_trace_negative_values() {
  function test_trace_1d_should_panic (line 100) | fn test_trace_1d_should_panic() {
  function test_trace_wrong_output_rank_should_panic (line 109) | fn test_trace_wrong_output_rank_should_panic() {

FILE: crates/burn-backend-tests/tests/tensor/float/linalg/vector_norm.rs
  function test_max_min_abs (line 8) | fn test_max_min_abs() {
  function test_l0_norm (line 68) | fn test_l0_norm() {
  function test_l1_norm (line 99) | fn test_l1_norm() {
  function test_lp_norm (line 120) | fn test_lp_norm() {
  function test_l2_norm (line 209) | fn test_l2_norm() {
  function test_normalize (line 231) | fn test_normalize() {

FILE: crates/burn-backend-tests/tests/tensor/float/module/adaptive_avgpool1d.rs
  function test_adaptive_avg_pool1d_simple (line 7) | fn test_adaptive_avg_pool1d_simple() {
  function test_adaptive_avg_pool1d_dyn_filter_size (line 22) | fn test_adaptive_avg_pool1d_dyn_filter_size() {
  function test_adaptive_avg_pool1d_bigger_output (line 34) | fn test_adaptive_avg_pool1d_bigger_output() {
  type AdaptiveAvgPool1dTestCase (line 48) | struct AdaptiveAvgPool1dTestCase {
    method assert_output (line 56) | fn assert_output(self, y: TestTensor<3>) {

FILE: crates/burn-backend-tests/tests/tensor/float/module/adaptive_avgpool2d.rs
  function test_adaptive_avg_pool2d_simple (line 7) | fn test_adaptive_avg_pool2d_simple() {
  function test_adaptive_avg_pool2d_dyn_filter_size (line 34) | fn test_adaptive_avg_pool2d_dyn_filter_size() {
  function test_adaptive_avg_pool2d_bigger_output (line 51) | fn test_adaptive_avg_pool2d_bigger_output() {
  type AdaptiveAvgPool2dTestCase (line 79) | struct AdaptiveAvgPool2dTestCase {
    method assert_output (line 89) | fn assert_output(self, y: TestTensor<4>) {

FILE: crates/burn-backend-tests/tests/tensor/float/module/attention.rs
  function test_attention_no_mask (line 9) | fn test_attention_no_mask() {
  function test_attention_custom_scale (line 59) | fn test_attention_custom_scale() {
  function test_attention_attn_bias (line 101) | fn test_attention_attn_bias() {
  function test_attention_softcap (line 144) | fn test_attention_softcap() {
  function test_attention_is_causal (line 186) | fn test_attention_is_causal() {
  function test_attention_cross_attention_with_bias (line 229) | fn test_attention_cross_attention_with_bias() {
  function test_attention_softcap_preserves_causal_mask (line 280) | fn test_attention_softcap_preserves_causal_mask() {
  function test_attention_all_options (line 319) | fn test_attention_all_options() {

FILE: crates/burn-backend-tests/tests/tensor/float/module/avgpool1d.rs
  function test_avg_pool1d_simple (line 7) | fn test_avg_pool1d_simple() {
  function test_avg_pool1d_complex (line 22) | fn test_avg_pool1d_complex() {
  function test_avg_pool1d_complex_dont_count_pad (line 40) | fn test_avg_pool1d_complex_dont_count_pad() {
  type AvgPool1dTestCase (line 57) | struct AvgPool1dTestCase {
    method assert_output (line 68) | fn assert_output(self, y: TestTensor<3>) {
  function test_avg_pool1d_ceil_mode (line 92) | fn test_avg_pool1d_ceil_mode() {
  function test_avg_pool1d_ceil_mode_count_include_pad (line 139) | fn test_avg_pool1d_ceil_mode_count_include_pad() {

FILE: crates/burn-backend-tests/tests/tensor/float/module/avgpool2d.rs
  function test_avg_pool2d_simple (line 7) | fn test_avg_pool2d_simple() {
  function test_avg_pool2d_complex (line 31) | fn test_avg_pool2d_complex() {
  function test_avg_pool2d_complex_dont_include_pad (line 55) | fn test_avg_pool2d_complex_dont_include_pad() {
  type AvgPool2dTestCase (line 78) | struct AvgPool2dTestCase {
    method assert_output (line 93) | fn assert_output(self, y: TestTensor<4>) {
  function test_avg_pool2d_ceil_mode (line 117) | fn test_avg_pool2d_ceil_mode() {
  function test_avg_pool2d_ceil_mode_count_include_pad (line 179) | fn test_avg_pool2d_ceil_mode_count_include_pad() {

FILE: crates/burn-backend-tests/tests/tensor/float/module/bicubic_interpolate.rs
  function test_upsample_interpolation (line 8) | fn test_upsample_interpolation() {
  function test_downsample_interpolation (line 69) | fn test_downsample_interpolation() {
  function test_1d_bicubic (line 88) | fn test_1d_bicubic() {
  type InterpolateTestCase (line 127) | struct InterpolateTestCase {
    method assert_output (line 137) | fn assert_output(self, y: TestTensor<4>) {
    method assert_output_with_align_corners (line 141) | fn assert_output_with_align_corners(self, y: TestTensor<4>, align_corn...
  function test_upsample_half_pixel (line 161) | fn test_upsample_half_pixel() {

FILE: crates/burn-backend-tests/tests/tensor/float/module/bilinear_interpolate.rs
  function test_upsample_interpolation (line 8) | fn test_upsample_interpolation() {
  function test_downsample_interpolation (line 69) | fn test_downsample_interpolation() {
  function test_1d_bilinear (line 88) | fn test_1d_bilinear() {
  function test_interpolate_coord_float_precision_boundary (line 136) | fn test_interpolate_coord_float_precision_boundary() {
  function should_interpolate_cast (line 175) | fn should_interpolate_cast() {
  type InterpolateTestCase (line 213) | struct InterpolateTestCase {
    method assert_output (line 223) | fn assert_output(self, y: TestTensor<4>) {
    method assert_output_with_align_corners (line 227) | fn assert_output_with_align_corners(self, y: TestTensor<4>, align_corn...
  function test_upsample_half_pixel (line 247) | fn test_upsample_half_pixel() {

FILE: crates/burn-backend-tests/tests/tensor/float/module/conv1d.rs
  function test_conv1d_simple (line 8) | fn test_conv1d_simple() {
  function test_conv1d_dilation (line 28) | fn test_conv1d_dilation() {
  function test_conv1d_groups (line 48) | fn test_conv1d_groups() {
  function test_conv1d_complex (line 68) | fn test_conv1d_complex() {
  type Conv1dTestCase (line 90) | struct Conv1dTestCase {
    method assert_output (line 103) | fn assert_output(self, y: TestTensor<3>) {

FILE: crates/burn-backend-tests/tests/tensor/float/module/conv2d.rs
  function test_conv2d_simple (line 10) | fn test_conv2d_simple() {
  function test_conv2d_simple_implicit (line 45) | fn test_conv2d_simple_implicit() {
  function test_conv2d_implicit_padded_in_channels (line 164) | fn test_conv2d_implicit_padded_in_channels() {
  function test_conv2d_groups_channels_out (line 283) | fn test_conv2d_groups_channels_out() {
  function test_conv2d_groups (line 402) | fn test_conv2d_groups() {
  function test_conv2d_groups_multiple_channels (line 431) | fn test_conv2d_groups_multiple_channels() {
  function test_conv2d_complex (line 474) | fn test_conv2d_complex() {
  type Conv2dTestCase (line 508) | struct Conv2dTestCase {
    method assert_output (line 526) | fn assert_output(self, y: TestTensor<4>) {
  function conv2d_weight (line 566) | fn conv2d_weight() -> TensorData {
  function test_conv2d_binary_broadcasted (line 574) | fn test_conv2d_binary_broadcasted() {

FILE: crates/burn-backend-tests/tests/tensor/float/module/conv3d.rs
  function test_conv3d_simple (line 8) | fn test_conv3d_simple() {
  function test_conv3d_groups (line 88) | fn test_conv3d_groups() {
  function test_conv3d_complex (line 150) | fn test_conv3d_complex() {
  type Conv3dTestCase (line 231) | struct Conv3dTestCase {
    method assert_output (line 254) | fn assert_output(self, y: TestTensor<5>) {

FILE: crates/burn-backend-tests/tests/tensor/float/module/conv_transpose1d.rs
  function test_conv_transpose1d_diff_channels (line 8) | fn test_conv_transpose1d_diff_channels() {
  function test_conv_transpose1d_stride (line 29) | fn test_conv_transpose1d_stride() {
  function test_conv_transpose1d_dilation (line 50) | fn test_conv_transpose1d_dilation() {
  function test_conv_transpose1d_groups (line 71) | fn test_conv_transpose1d_groups() {
  type ConvTranspose1dTestCase (line 91) | struct ConvTranspose1dTestCase {
    method assert_output (line 105) | fn assert_output(self, y: TestTensor<3>) {

FILE: crates/burn-backend-tests/tests/tensor/float/module/conv_transpose2d.rs
  function test_conv_transpose2d_simple_1 (line 8) | fn test_conv_transpose2d_simple_1() {
  function test_conv_transpose2d_simple_2 (line 32) | fn test_conv_transpose2d_simple_2() {
  function test_conv_transpose2d_simple_3 (line 75) | fn test_conv_transpose2d_simple_3() {
  function test_conv_transpose2d_stride_2 (line 103) | fn test_conv_transpose2d_stride_2() {
  function test_conv_transpose2d_dilation_2 (line 132) | fn test_conv_transpose2d_dilation_2() {
  function test_conv_transpose2d_stride2_out_padding (line 171) | fn test_conv_transpose2d_stride2_out_padding() {
  function test_conv_transpose2d_groups_2 (line 216) | fn test_conv_transpose2d_groups_2() {
  function test_conv_transpose2d_groups_different_channels (line 243) | fn test_conv_transpose2d_groups_different_channels() {
  type ConvTranspose2dTestCase (line 303) | struct ConvTranspose2dTestCase {
    method assert_output (line 323) | fn assert_output(self, y: TestTensor<4>) {

FILE: crates/burn-backend-tests/tests/tensor/float/module/conv_transpose3d.rs
  function test_conv_transpose3d_simple_1 (line 8) | fn test_conv_transpose3d_simple_1() {
  function test_conv_transpose3d_simple_2 (line 40) | fn test_conv_transpose3d_simple_2() {
  function test_conv_transpose3d_stride_2 (line 149) | fn test_conv_transpose3d_stride_2() {
  function test_conv_transpose3d_dilation_2 (line 204) | fn test_conv_transpose3d_dilation_2() {
  function test_conv_transpose3d_stride2_out_padding (line 309) | fn test_conv_transpose3d_stride2_out_padding() {
  function test_conv_transpose3d_groups_2 (line 456) | fn test_conv_transpose3d_groups_2() {
  function test_conv_transpose3d_groups_different_channels (line 492) | fn test_conv_transpose3d_groups_different_channels() {
  type ConvTranspose3dTestCase (line 678) | struct ConvTranspose3dTestCase {
    method assert_output (line 704) | fn assert_output(self, y: TestTensor<5>) {

FILE: crates/burn-backend-tests/tests/tensor/float/module/deform_conv2d.rs
  function test_deform_conv2d_simple (line 8) | fn test_deform_conv2d_simple() {
  function test_deform_conv2d_batched (line 37) | fn test_deform_conv2d_batched() {
  function test_deform_conv2d_weight_groups (line 75) | fn test_deform_conv2d_weight_groups() {
  function test_deform_conv2d_offset_groups (line 105) | fn test_deform_conv2d_offset_groups() {
  function test_deform_conv2d_different_kernel_size (line 135) | fn test_deform_conv2d_different_kernel_size() {
  function test_deform_conv2d_different_padding_size (line 162) | fn test_deform_conv2d_different_padding_size() {
  function test_deform_conv2d_different_stride (line 246) | fn test_deform_conv2d_different_stride() {
  function test_deform_conv2d_different_dilation (line 273) | fn test_deform_conv2d_different_dilation() {
  function test_deform_conv2d_different_width (line 300) | fn test_deform_conv2d_different_width() {
  type DeformConv2dTestCase (line 341) | struct DeformConv2dTestCase {
    method assert_output (line 360) | fn assert_output(self, y: Tensor<TestBackend, 4>) {

FILE: crates/burn-backend-tests/tests/tensor/float/module/forward.rs
  function test_embedding_forward (line 5) | fn test_embedding_forward() {

FILE: crates/burn-backend-tests/tests/tensor/float/module/lanczos3_interpolate.rs
  function test_upsample_interpolation (line 8) | fn test_upsample_interpolation() {
  function test_downsample_interpolation (line 69) | fn test_downsample_interpolation() {
  function test_upsample_2x (line 88) | fn test_upsample_2x() {
  function test_upsample_half_pixel (line 127) | fn test_upsample_half_pixel() {
  function test_1d_lanczos3 (line 169) | fn test_1d_lanczos3() {
  type InterpolateTestCase (line 204) | struct InterpolateTestCase {
    method assert_output (line 214) | fn assert_output(self, y: TestTensor<4>) {
    method assert_output_with_align_corners (line 218) | fn assert_output_with_align_corners(self, y: TestTensor<4>, align_corn...

FILE: crates/burn-backend-tests/tests/tensor/float/module/linear.rs
  function test_linear_1d (line 7) | fn test_linear_1d() {
  function test_linear_1d_one_element_output (line 20) | fn test_linear_1d_one_element_output() {
  function test_linear_forward_no_bias (line 33) | fn test_linear_forward_no_bias() {
  function test_linear_forward_with_bias (line 47) | fn test_linear_forward_with_bias() {

FILE: crates/burn-backend-tests/tests/tensor/float/module/maxpool1d.rs
  function test_max_pool1d_simple (line 7) | fn test_max_pool1d_simple() {
  function test_max_pool1d_different_padding_stride_kernel (line 29) | fn test_max_pool1d_different_padding_stride_kernel() {
  function test_max_pool1d_with_neg (line 45) | fn test_max_pool1d_with_neg() {
  function test_max_pool1d_with_dilation (line 61) | fn test_max_pool1d_with_dilation() {
  function test_max_pool1d_with_indices (line 83) | fn test_max_pool1d_with_indices() {
  function test_max_pool1d_complex (line 102) | fn test_max_pool1d_complex() {
  function test_max_pool1d_ceil_mode (line 121) | fn test_max_pool1d_ceil_mode() {

FILE: crates/burn-backend-tests/tests/tensor/float/module/maxpool2d.rs
  function test_max_pool2d_simple (line 7) | fn test_max_pool2d_simple() {
  function test_max_pool2d_different_padding_stride_kernel (line 108) | fn test_max_pool2d_different_padding_stride_kernel() {
  function test_max_pool2d_with_neg (line 149) | fn test_max_pool2d_with_neg() {
  function test_max_pool2d_with_dilation (line 191) | fn test_max_pool2d_with_dilation() {
  function test_max_pool2d_with_indices (line 230) | fn test_max_pool2d_with_indices() {
  function test_max_pool2d_complex (line 276) | fn test_max_pool2d_complex() {
  function test_max_pool2d_ceil_mode (line 324) | fn test_max_pool2d_ceil_mode() {
  function test_max_pool2d_ceil_mode_with_indices (line 404) | fn test_max_pool2d_ceil_mode_with_indices() {
  function test_max_pool2d_ceil_mode_with_indices_and_padding (line 464) | fn test_max_pool2d_ceil_mode_with_indices_and_padding() {

FILE: crates/burn-backend-tests/tests/tensor/float/module/nearest_interpolate.rs
  function test_upsample_interpolation (line 8) | fn test_upsample_interpolation() {
  function test_downsample_interpolation (line 43) | fn test_downsample_interpolation() {
  function test_1d_nearest (line 62) | fn test_1d_nearest() {
  type InterpolateTestCase (line 100) | struct InterpolateTestCase {
    method assert_output (line 110) | fn assert_output(self, y: TestTensor<4>) {

FILE: crates/burn-backend-tests/tests/tensor/float/module/unfold4d.rs
  function test_unfold4d_shape (line 8) | fn test_unfold4d_shape() {
  function test_unfold4d_simple (line 24) | fn test_unfold4d_simple() {
  function test_unfold4d_complex (line 49) | fn test_unfold4d_complex() {
  type Unfold4dTestCase (line 77) | struct Unfold4dTestCase {
    method assert_shape (line 89) | fn assert_shape(self, expected_shape: [usize; 3]) {
    method assert_output (line 111) | fn assert_output(self, expected: TestTensor<3>) {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/abs.rs
  function should_support_abs_ops_float (line 5) | fn should_support_abs_ops_float() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/add.rs
  function test_add_d2 (line 5) | fn test_add_d2() {
  function test_add_broadcast (line 18) | fn test_add_broadcast() {
  function test_add_different_strides_rhs (line 31) | fn test_add_different_strides_rhs() {
  function test_add_different_strides_lhs (line 45) | fn test_add_different_strides_lhs() {
  function test_add_different_strides_broadcast (line 59) | fn test_add_different_strides_broadcast() {
  function should_support_add_scalar_ops (line 73) | fn should_support_add_scalar_ops() {
  function add_maybe_fused_not_contiguous (line 85) | fn add_maybe_fused_not_contiguous() {
  function add_maybe_fused_not_contiguous_broadcasted (line 103) | fn add_maybe_fused_not_contiguous_broadcasted() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/aggregation.rs
  function test_should_mean (line 7) | fn test_should_mean() {
  function test_should_sum (line 19) | fn test_should_sum() {
  function test_should_sum_dim_maybe_fused (line 30) | fn test_should_sum_dim_maybe_fused() {
  function test_should_mean_last_dim (line 50) | fn test_should_mean_last_dim() {
  function test_should_sum_last_dim (line 68) | fn test_should_sum_last_dim() {
  function test_should_sum_first_dim (line 79) | fn test_should_sum_first_dim() {
  function test_should_mean_first_dim (line 90) | fn test_should_mean_first_dim() {
  function test_should_sum_mid_dim_3d_non_contiguous_1 (line 102) | fn test_should_sum_mid_dim_3d_non_contiguous_1() {
  function test_should_sum_mid_dim_3d_non_contiguous_2 (line 117) | fn test_should_sum_mid_dim_3d_non_contiguous_2() {
  function test_prod_float (line 132) | fn test_prod_float() {
  function test_prod_dim_float (line 151) | fn test_prod_dim_float() {
  function test_sum_dim_2d (line 170) | fn test_sum_dim_2d() {
  function test_sum_dims_2d (line 186) | fn test_sum_dims_2d() {
  function test_sum_and_squeeze_dims (line 210) | fn test_sum_and_squeeze_dims() {
  function test_sum_dim_1_reshape_maybe_fused (line 226) | fn test_sum_dim_1_reshape_maybe_fused() {
  function test_sum_dim_1_swap_dims_maybe_fused (line 238) | fn test_sum_dim_1_swap_dims_maybe_fused() {
  function test_sum_dim_2_reshape_maybe_fused_broadcast (line 251) | fn test_sum_dim_2_reshape_maybe_fused_broadcast() {
  function test_sum_dim_2_maybe_fused_on_write (line 263) | fn test_sum_dim_2_maybe_fused_on_write() {
  function test_sum_dim_3_maybe_fused_on_read_not_contiguous (line 278) | fn test_sum_dim_3_maybe_fused_on_read_not_contiguous() {
  function test_sum_dim_4_maybe_fused_on_read_not_contiguous_mixed (line 296) | fn test_sum_dim_4_maybe_fused_on_read_not_contiguous_mixed() {
  function test_sum_dim_5_maybe_fused_on_read_not_contiguous_mixed (line 316) | fn test_sum_dim_5_maybe_fused_on_read_not_contiguous_mixed() {
  function test_sum_dim_6_maybe_fused_on_read_not_contiguous_broadcasted (line 336) | fn test_sum_dim_6_maybe_fused_on_read_not_contiguous_broadcasted() {
  function test_sum_dim_7_maybe_fused_on_read_reshaped (line 366) | fn test_sum_dim_7_maybe_fused_on_read_reshaped() {
  function test_mean_dim_fused_on_read_on_write (line 382) | fn test_mean_dim_fused_on_read_on_write() {
  function test_mean_dim_2d (line 401) | fn test_mean_dim_2d() {
  function test_mean_dims_2d (line 421) | fn test_mean_dims_2d() {
  function test_multiple_reduce_dims_permuted (line 445) | fn test_multiple_reduce_dims_permuted() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/all.rs
  function test_all (line 5) | fn test_all() {
  function test_all_dim (line 13) | fn test_all_dim() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/any.rs
  function test_any (line 5) | fn test_any() {
  function test_any_dim (line 41) | fn test_any_dim() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/arg.rs
  function test_argmax_2d_dim0 (line 5) | fn test_argmax_2d_dim0() {
  function test_argmin_2d_dim0 (line 16) | fn test_argmin_2d_dim0() {
  function test_argmax_2d_dim1 (line 27) | fn test_argmax_2d_dim1() {
  function test_argmin_2d_dim1 (line 38) | fn test_argmin_2d_dim1() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/cast.rs
  function cast_float_to_bool (line 6) | fn cast_float_to_bool() {
  function cast_float_to_int (line 14) | fn cast_float_to_int() {
  function cast_int_to_float_tensor (line 22) | fn cast_int_to_float_tensor() {
  function cast_bool_to_float_tensor (line 31) | fn cast_bool_to_float_tensor() {
  function cast_float_precision (line 40) | fn cast_float_precision() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/cat.rs
  function should_support_cat_ops_2d_dim0 (line 7) | fn should_support_cat_ops_2d_dim0() {
  function should_support_cat_ops_2d_dim1 (line 21) | fn should_support_cat_ops_2d_dim1() {
  function should_support_cat_ops_3d (line 35) | fn should_support_cat_ops_3d() {
  function should_panic_when_dimensions_are_not_the_same (line 50) | fn should_panic_when_dimensions_are_not_the_same() {
  function should_panic_when_list_of_vectors_is_empty (line 60) | fn should_panic_when_list_of_vectors_is_empty() {
  function should_panic_when_cat_exceeds_dimension (line 67) | fn should_panic_when_cat_exceeds_dimension() {
  function should_support_cat_ops_cast_dtype (line 76) | fn should_support_cat_ops_cast_dtype() {
  function should_support_cat_with_empty_tensor (line 92) | fn should_support_cat_with_empty_tensor() {
  function should_support_cat_with_empty_tensor_first (line 107) | fn should_support_cat_with_empty_tensor_first() {
  function should_support_cat_with_multiple_empty_tensors (line 122) | fn should_support_cat_with_multiple_empty_tensors() {
  function should_support_cat_all_empty_tensors (line 139) | fn should_support_cat_all_empty_tensors() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/ceil.rs
  function should_support_ceil_ops (line 6) | fn should_support_ceil_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/chunk.rs
  function test_chunk_evenly_divisible (line 5) | fn test_chunk_evenly_divisible() {
  function test_chunk_not_evenly_divisible (line 26) | fn test_chunk_not_evenly_divisible() {
  function test_chunk_not_evenly_divisible_remains_several (line 47) | fn test_chunk_not_evenly_divisible_remains_several() {
  function test_chunk_not_divisible (line 61) | fn test_chunk_not_divisible() {
  function test_invalid_dim (line 83) | fn test_invalid_dim() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/clamp.rs
  function clamp_min (line 5) | fn clamp_min() {
  function clamp_max (line 28) | fn clamp_max() {
  function clamp_min_max (line 51) | fn clamp_min_max() {
  function clamp_min_max_vec_should_compile (line 73) | fn clamp_min_max_vec_should_compile() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/close.rs
  function test_is_close (line 5) | fn test_is_close() {
  function test_all_close (line 24) | fn test_all_close() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/comparison.rs
  function test_equal_inf (line 5) | fn test_equal_inf() {
  function test_not_equal_inf (line 21) | fn test_not_equal_inf() {
  function test_equal (line 37) | fn test_equal() {
  function test_not_equal (line 50) | fn test_not_equal() {
  function test_equal_elem (line 63) | fn test_equal_elem() {
  function test_not_equal_elem (line 75) | fn test_not_equal_elem() {
  function greater_elem (line 87) | fn greater_elem() {
  function test_greater_equal_elem (line 99) | fn test_greater_equal_elem() {
  function test_greater (line 111) | fn test_greater() {
  function test_greater_equal (line 124) | fn test_greater_equal() {
  function test_lower_elem (line 137) | fn test_lower_elem() {
  function test_lower_equal_elem (line 149) | fn test_lower_equal_elem() {
  function test_lower (line 161) | fn test_lower() {
  function test_lower_equal (line 174) | fn test_lower_equal() {
  function test_greater_broadcast (line 187) | fn test_greater_broadcast() {
  function test_greater_equal_broadcast (line 212) | fn test_greater_equal_broadcast() {
  function test_lower_broadcast (line 232) | fn test_lower_broadcast() {
  function test_lower_equal_broadcast (line 253) | fn test_lower_equal_broadcast() {
  function test_equal_broadcast (line 268) | fn test_equal_broadcast() {
  function test_not_equal_broadcast (line 287) | fn test_not_equal_broadcast() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/create_like.rs
  function should_support_zeros_like (line 6) | fn should_support_zeros_like() {
  function should_support_ones_like (line 24) | fn should_support_ones_like() {
  function should_support_randoms_like (line 42) | fn should_support_randoms_like() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/cross.rs
  function test_cross_3d_last_dim (line 8) | fn test_cross_3d_last_dim() {
  function test_cross_3d_non_contiguous_last_dim (line 21) | fn test_cross_3d_non_contiguous_last_dim() {
  function test_cross_3d_dim0 (line 36) | fn test_cross_3d_dim0() {
  function test_cross_3d_broadcast (line 49) | fn test_cross_3d_broadcast() {
  function test_cross_4d_last_dim (line 62) | fn test_cross_4d_last_dim() {
  function manual_cross (line 75) | fn manual_cross(a: &[[f32; 3]], b: &[[f32; 3]]) -> Vec<[f32; 3]> {
  function forward_matches_manual_cross (line 89) | fn forward_matches_manual_cross() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/cumulative.rs
  function test_cumsum_float_dim_0 (line 5) | fn test_cumsum_float_dim_0() {
  function test_cumsum_float_dim_1 (line 16) | fn test_cumsum_float_dim_1() {
  function test_cumsum_non_contiguous (line 28) | fn test_cumsum_non_contiguous() {
  function test_cumsum_float_3d (line 39) | fn test_cumsum_float_3d() {
  function test_cumprod_float_dim_0 (line 51) | fn test_cumprod_float_dim_0() {
  function test_cumprod_float_dim_1 (line 63) | fn test_cumprod_float_dim_1() {
  function test_cumprod_float_3d (line 75) | fn test_cumprod_float_3d() {
  function test_cummin_float_dim_0 (line 87) | fn test_cummin_float_dim_0() {
  function test_cummin_float_dim_1 (line 98) | fn test_cummin_float_dim_1() {
  function test_cummin_float_3d (line 109) | fn test_cummin_float_3d() {
  function test_cummax_float_dim_0 (line 121) | fn test_cummax_float_dim_0() {
  function test_cummax_float_dim_1 (line 132) | fn test_cummax_float_dim_1() {
  function test_cummax_float_3d (line 143) | fn test_cummax_float_3d() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/div.rs
  function should_support_div_ops (line 6) | fn should_support_div_ops() {
  function test_div_broadcast (line 22) | fn test_div_broadcast() {
  function should_support_div_scalar_ops (line 38) | fn should_support_div_scalar_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/dot.rs
  function test_float (line 5) | fn test_float() {
  function test_int (line 17) | fn test_int() {
  function test_panics_for_different_sizes (line 30) | fn test_panics_for_different_sizes() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/erf.rs
  function should_support_erf_ops (line 6) | fn should_support_erf_ops() {
  function should_support_erf_ops_with_negative_number (line 20) | fn should_support_erf_ops_with_negative_number() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/exp.rs
  function should_support_exp_ops (line 6) | fn should_support_exp_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/expand.rs
  function expand_2d (line 5) | fn expand_2d() {
  function expand_3d (line 24) | fn expand_3d() {
  function expand_higher_dimensions (line 37) | fn expand_higher_dimensions() {
  function expand_sum_3d (line 57) | fn expand_sum_3d() {
  function broadcast_single (line 66) | fn broadcast_single() {
  function should_fail_expand_incompatible_shapes (line 77) | fn should_fail_expand_incompatible_shapes() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/finite.rs
  function is_finite (line 4) | fn is_finite() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/flatten.rs
  function should_flatten_to_1d (line 6) | fn should_flatten_to_1d() {
  function should_flatten_middle (line 15) | fn should_flatten_middle() {
  function should_flatten_begin (line 24) | fn should_flatten_begin() {
  function should_flatten_end (line 33) | fn should_flatten_end() {
  function should_flatten_end_negative_indices (line 42) | fn should_flatten_end_negative_indices() {
  function should_flatten_panic (line 52) | fn should_flatten_panic() {
  function not_enough_destination_dimension (line 59) | fn not_enough_destination_dimension() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/flip.rs
  function flip_float (line 5) | fn flip_float() {
  function flip_duplicated_axes (line 32) | fn flip_duplicated_axes() {
  function flip_out_of_bound_axis (line 42) | fn flip_out_of_bound_axis() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/floor.rs
  function should_support_floor_ops (line 6) | fn should_support_floor_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/fmod.rs
  function should_support_fmod_ops (line 9) | fn should_support_fmod_ops() {
  function should_support_fmod_scalar (line 25) | fn should_support_fmod_scalar() {
  function should_handle_positive_dividend_positive_divisor (line 38) | fn should_handle_positive_dividend_positive_divisor() {
  function should_handle_negative_dividend (line 54) | fn should_handle_negative_dividend() {
  function should_handle_mixed_signs (line 70) | fn should_handle_mixed_signs() {
  function should_handle_infinity_dividend (line 87) | fn should_handle_infinity_dividend() {
  function should_handle_zero_divisor (line 112) | fn should_handle_zero_divisor() {
  function should_handle_infinity_divisor (line 132) | fn should_handle_infinity_divisor() {
  function should_handle_nan_arguments (line 154) | fn should_handle_nan_arguments() {
  function should_handle_negative_zero (line 173) | fn should_handle_negative_zero() {
  function should_support_fmod_broadcasting_2d (line 194) | fn should_support_fmod_broadcasting_2d() {
  function should_support_fmod_broadcasting_3d (line 215) | fn should_support_fmod_broadcasting_3d() {
  function should_support_fmod_scalar_broadcasting (line 235) | fn should_support_fmod_scalar_broadcasting() {
  function should_handle_edge_case_values (line 249) | fn should_handle_edge_case_values() {
  function should_handle_special_scalar_cases (line 266) | fn should_handle_special_scalar_cases() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/full.rs
  function test_data_full (line 5) | fn test_data_full() {
  function test_tensor_full (line 12) | fn test_tensor_full() {
  function test_tensor_full_options (line 21) | fn test_tensor_full_options() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/gather_scatter.rs
  function should_gather_1d_dim0 (line 5) | fn should_gather_1d_dim0() {
  function should_gather_2d_dim0 (line 18) | fn should_gather_2d_dim0() {
  function should_gather_2d_dim1 (line 31) | fn should_gather_2d_dim1() {
  function should_gather_3d_dim1 (line 45) | fn should_gather_3d_dim1() {
  function should_gather_2d_only_1dim (line 67) | fn should_gather_2d_only_1dim() {
  function should_scatter_add_1d (line 80) | fn should_scatter_add_1d() {
  function should_scatter_add_2d_dim0 (line 94) | fn should_scatter_add_2d_dim0() {
  function should_scatter_add_2d_dim1 (line 108) | fn should_scatter_add_2d_dim1() {
  function should_scatter_add_3d_dim1 (line 122) | fn should_scatter_add_3d_dim1() {
  function should_scatter_add_2d_dim1_diff_shape (line 151) | fn should_scatter_add_2d_dim1_diff_shape() {
  function scatter_should_panic_on_mismatch_of_shapes (line 166) | fn scatter_should_panic_on_mismatch_of_shapes() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/grid_sample.rs
  function should_grid_sample_2d_default (line 15) | fn should_grid_sample_2d_default() {
  function should_grid_sample_2d_align_corners_border (line 39) | fn should_grid_sample_2d_align_corners_border() {
  function should_pad_zeros_grid_sample_2d (line 65) | fn should_pad_zeros_grid_sample_2d() {
  function should_pad_border_grid_sample_2d (line 84) | fn should_pad_border_grid_sample_2d() {
  function should_pad_reflection_grid_sample_2d (line 106) | fn should_pad_reflection_grid_sample_2d() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/inf.rs
  function is_inf (line 4) | fn is_inf() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/init.rs
  function should_support_float_empty (line 5) | fn should_support_float_empty() {
  function should_support_float_empty_options (line 12) | fn should_support_float_empty_options() {
  function should_support_float_zeros (line 19) | fn should_support_float_zeros() {
  function should_support_float_zeros_options (line 30) | fn should_support_float_zeros_options() {
  function should_support_float_ones (line 42) | fn should_support_float_ones() {
  function should_support_float_ones_options (line 53) | fn should_support_float_ones_options() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/iter_dim.rs
  function test_1d_iter_last_item (line 5) | fn test_1d_iter_last_item() {
  function test_too_high_dimension (line 19) | fn test_too_high_dimension() {
  function test_transposed (line 24) | fn test_transposed() {
  function test_2d_iter_dim (line 40) | fn test_2d_iter_dim() {
  function test_2d_iter_dim1 (line 60) | fn test_2d_iter_dim1() {
  function test_3d_iter_dim (line 85) | fn test_3d_iter_dim() {
  function test_3d_iter_dim1 (line 101) | fn test_3d_iter_dim1() {
  function test_3d_iter_dim2 (line 129) | fn test_3d_iter_dim2() {
  function test_iteration_over_low_dim (line 167) | fn test_iteration_over_low_dim() {
  function test_iter_dim_double_end (line 185) | fn test_iter_dim_double_end() {
  function test_iter_dim_single_element (line 228) | fn test_iter_dim_single_element() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/log.rs
  function should_support_log_ops (line 6) | fn should_support_log_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/log1p.rs
  function should_support_exp_log1p (line 6) | fn should_support_exp_log1p() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/mask.rs
  function should_support_mask_fill_swap_dims (line 6) | fn should_support_mask_fill_swap_dims() {
  function should_support_mask_where_ops (line 26) | fn should_support_mask_where_ops() {
  function should_support_mask_where_broadcast (line 40) | fn should_support_mask_where_broadcast() {
  function should_support_mask_where_broadcast_value_small (line 67) | fn should_support_mask_where_broadcast_value_small() {
  function should_handle_mask_where_nans (line 80) | fn should_handle_mask_where_nans() {
  function should_support_mask_fill_ops (line 116) | fn should_support_mask_fill_ops() {
  function should_support_mask_fill_broadcasted (line 129) | fn should_support_mask_fill_broadcasted() {
  function float_mask_fill_infinite (line 149) | fn float_mask_fill_infinite() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/matmul.rs
  function test_float_matmul_d2 (line 6) | fn test_float_matmul_d2() {
  function test_float_matmul_d3 (line 18) | fn test_float_matmul_d3() {
  function test_float_matmul_broadcast_1 (line 30) | fn test_float_matmul_broadcast_1() {
  function test_float_matmul_broadcast_4d (line 45) | fn test_float_matmul_broadcast_4d() {
  function test_float_matmul_simple_1 (line 69) | fn test_float_matmul_simple_1() {
  function test_float_matmul_4_3 (line 81) | fn test_float_matmul_4_3() {
  function test_float_matmul_batch_vec_mat (line 99) | fn test_float_matmul_batch_vec_mat() {
  function test_float_matmul_trivial (line 122) | fn test_float_matmul_trivial() {
  function test_float_matmul_trivial_transposed (line 143) | fn test_float_matmul_trivial_transposed() {
  function test_float_matmul_vecmat_transposed_fused (line 165) | fn test_float_matmul_vecmat_transposed_fused() {
  function test_float_matmul_4_8 (line 201) | fn test_float_matmul_4_8() {
  function test_float_matmul_simple_2 (line 222) | fn test_float_matmul_simple_2() {
  function test_float_matmul_simple_3 (line 234) | fn test_float_matmul_simple_3() {
  function float_should_panic_when_inner_dimensions_are_not_equal (line 258) | fn float_should_panic_when_inner_dimensions_are_not_equal() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/maxmin.rs
  function test_max_dim_2d (line 5) | fn test_max_dim_2d() {
  function test_max_dims_2d (line 37) | fn test_max_dims_2d() {
  function test_max_dim_with_indices_2d_with_dim_0th (line 57) | fn test_max_dim_with_indices_2d_with_dim_0th() {
  function test_max_dim_with_indices_2d (line 74) | fn test_max_dim_with_indices_2d() {
  function test_max_dim_2d_with_0th_dim (line 88) | fn test_max_dim_2d_with_0th_dim() {
  function test_max_pair (line 99) | fn test_max_pair() {
  function test_min_dim_2d (line 110) | fn test_min_dim_2d() {
  function test_min_dims_2d (line 142) | fn test_min_dims_2d() {
  function test_min_dim_with_indices_2d (line 162) | fn test_min_dim_with_indices_2d() {
  function test_min_dim_2d_with_0th_dim (line 176) | fn test_min_dim_2d_with_0th_dim() {
  function test_min_dim_with_indices_2d_with_0th_dim (line 187) | fn test_min_dim_with_indices_2d_with_0th_dim() {
  function test_min_pair (line 204) | fn test_min_pair() {
  function test_max_abs (line 215) | fn test_max_abs() {
  function test_max_abs_dim_2d_dim_0 (line 225) | fn test_max_abs_dim_2d_dim_0() {
  function test_max_abs_dims_2d (line 239) | fn test_max_abs_dims_2d() {
  function test_max_abs_dim_2d_dim_1 (line 262) | fn test_max_abs_dim_2d_dim_1() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/movedim.rs
  function movedim_float (line 5) | fn movedim_float() {
  function vec_input_float (line 32) | fn vec_input_float() {
  function different_input_types (line 59) | fn different_input_types() {
  function edge_different_sizes (line 87) | fn edge_different_sizes() {
  function edge_out_of_bound_axis (line 97) | fn edge_out_of_bound_axis() {
  function edge_vec_is_not_a_set (line 107) | fn edge_vec_is_not_a_set() {
  function edge_out_of_bound_axis_vec (line 117) | fn edge_out_of_bound_axis_vec() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/mul.rs
  function should_support_mul_ops (line 5) | fn should_support_mul_ops() {
  function test_mul_broadcast (line 19) | fn test_mul_broadcast() {
  function test_mul_broadcast_2_dims (line 33) | fn test_mul_broadcast_2_dims() {
  function should_support_mul_scalar_ops (line 45) | fn should_support_mul_scalar_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/nan.rs
  function is_nan (line 5) | fn is_nan() {
  function contains_nan (line 18) | fn contains_nan() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/narrow.rs
  function test_narrow_1 (line 6) | fn test_narrow_1() {
  function test_narrow_2 (line 22) | fn test_narrow_2() {
  function test_narrow_3 (line 37) | fn test_narrow_3() {
  function test_narrow_invalid_dim (line 58) | fn test_narrow_invalid_dim() {
  function test_narrow_invalid_start (line 69) | fn test_narrow_invalid_start() {
  function test_narrow_invalid_zero_length (line 80) | fn test_narrow_invalid_zero_length() {
  function test_narrow_invalid_length (line 91) | fn test_narrow_invalid_length() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/neg.rs
  function should_support_neg_ops (line 5) | fn should_support_neg_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/one_hot.rs
  function float_should_support_one_hot (line 5) | fn float_should_support_one_hot() {
  function float_should_support_one_hot_index (line 17) | fn float_should_support_one_hot_index() {
  function float_one_hot_should_panic_when_index_exceeds_number_of_classes (line 26) | fn float_one_hot_should_panic_when_index_exceeds_number_of_classes() {
  function float_one_hot_should_panic_when_number_of_classes_is_zero (line 33) | fn float_one_hot_should_panic_when_number_of_classes_is_zero() {
  function one_hot_fill_with_negative_axis_and_indices (line 39) | fn one_hot_fill_with_negative_axis_and_indices() {
  function one_hot_fill_with_negative_indices (line 52) | fn one_hot_fill_with_negative_indices() {
  function one_hot_fill_should_panic_when_axis_out_range_of_rank (line 67) | fn one_hot_fill_should_panic_when_axis_out_range_of_rank() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/padding.rs
  function padding_constant_2d_test (line 5) | fn padding_constant_2d_test() {
  function padding_constant_4d_test (line 23) | fn padding_constant_4d_test() {
  function padding_constant_asymmetric_test (line 42) | fn padding_constant_asymmetric_test() {
  function padding_reflect_2d_test (line 64) | fn padding_reflect_2d_test() {
  function padding_reflect_width_only_test (line 91) | fn padding_reflect_width_only_test() {
  function padding_reflect_4d_test (line 106) | fn padding_reflect_4d_test() {
  function padding_edge_2d_test (line 123) | fn padding_edge_2d_test() {
  function padding_edge_width_only_test (line 140) | fn padding_edge_width_only_test() {
  function padding_edge_4d_test (line 155) | fn padding_edge_4d_test() {
  function padding_constant_default_test (line 171) | fn padding_constant_default_test() {
  function padding_reflect_max_valid_test (line 187) | fn padding_reflect_max_valid_test() {
  function padding_reflect_asymmetric_test (line 204) | fn padding_reflect_asymmetric_test() {
  function padding_reflect_exceeds_dimension_test (line 224) | fn padding_reflect_exceeds_dimension_test() {
  function padding_edge_asymmetric_test (line 233) | fn padding_edge_asymmetric_test() {
  function padding_zero_padding_test (line 252) | fn padding_zero_padding_test() {
  function padding_empty_tensor_constant_test (line 267) | fn padding_empty_tensor_constant_test() {
  function padding_empty_tensor_edge_panics_test (line 289) | fn padding_empty_tensor_edge_panics_test() {
  function padding_empty_tensor_reflect_panics_test (line 299) | fn padding_empty_tensor_reflect_panics_test() {
  function padding_constant_pairs_2d_test (line 310) | fn padding_constant_pairs_2d_test() {
  function padding_constant_single_dim_test (line 329) | fn padding_constant_single_dim_test() {
  function padding_constant_all_dims_4d_test (line 340) | fn padding_constant_all_dims_4d_test() {
  function padding_constant_batch_dim_only_test (line 372) | fn padding_constant_batch_dim_only_test() {
  function padding_reflect_pairs_test (line 390) | fn padding_reflect_pairs_test() {
  function padding_edge_pairs_test (line 407) | fn padding_edge_pairs_test() {
  function padding_reflect_batch_dim_3d_test (line 423) | fn padding_reflect_batch_dim_3d_test() {
  function padding_edge_batch_dim_3d_test (line 445) | fn padding_edge_batch_dim_3d_test() {
  function padding_too_many_pairs_panics_test (line 465) | fn padding_too_many_pairs_panics_test() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/permute.rs
  function permute_float_a (line 5) | fn permute_float_a() {
  function permute_float (line 32) | fn permute_float() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/powf.rs
  function should_support_powf_ops (line 6) | fn should_support_powf_ops() {
  function should_support_neg_power (line 21) | fn should_support_neg_power() {
  function should_support_neg_values_with_even_power (line 36) | fn should_support_neg_values_with_even_power() {
  function should_support_neg_values_with_odd_power (line 51) | fn should_support_neg_values_with_odd_power() {
  function should_support_powf_broadcasted (line 66) | fn should_support_powf_broadcasted() {
  function outer (line 84) | fn outer(a: TestTensor<1>, b: TestTensor<1>) -> TestTensor<2> {
  function should_support_powf_scalar_tensor (line 89) | fn should_support_powf_scalar_tensor() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/powf_scalar.rs
  function should_support_powf_ops (line 6) | fn should_support_powf_ops() {
  function should_support_neg_power (line 19) | fn should_support_neg_power() {
  function should_support_neg_values_with_even_power (line 32) | fn should_support_neg_values_with_even_power() {
  function should_support_neg_values_with_odd_power (line 45) | fn should_support_neg_values_with_odd_power() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/prod.rs
  function test_prod_float (line 5) | fn test_prod_float() {
  function test_prod_dim_2d (line 16) | fn test_prod_dim_2d() {
  function test_prod_dims_2d (line 31) | fn test_prod_dims_2d() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/random.rs
  function rand_default (line 5) | fn rand_default() {
  function rand_uniform (line 20) | fn rand_uniform() {
  function rand_bernoulli (line 33) | fn rand_bernoulli() {
  function test_seed_reproducibility (line 44) | fn test_seed_reproducibility() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/recip.rs
  function should_support_recip_ops (line 6) | fn should_support_recip_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/remainder.rs
  function should_support_remainder_basic (line 7) | fn should_support_remainder_basic() {
  function should_support_remainder_basic_scalar (line 21) | fn should_support_remainder_basic_scalar() {
  function should_support_remainder_float (line 35) | fn should_support_remainder_float() {
  function should_support_remainder_float_scalar (line 57) | fn should_support_remainder_float_scalar() {
  function should_be_zero (line 71) | fn should_be_zero() {
  function should_be_zero_scalar (line 85) | fn should_be_zero_scalar() {
  function should_have_no_remainder (line 99) | fn should_have_no_remainder() {
  function should_have_no_remainder_scalar (line 122) | fn should_have_no_remainder_scalar() {
  function should_be_negative (line 136) | fn should_be_negative() {
  function should_be_negative_scalar (line 151) | fn should_be_negative_scalar() {
  function should_support_fp_dividends (line 165) | fn should_support_fp_dividends() {
  function should_support_large_divisor (line 181) | fn should_support_large_divisor() {
  function should_support_large_divisor_scalar (line 201) | fn should_support_large_divisor_scalar() {
  function should_support_remainder_op (line 215) | fn should_support_remainder_op() {
  function should_support_remainder_scalar_op (line 230) | fn should_support_remainder_scalar_op() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/repeat.rs
  function should_support_repeat_ops_one_dimension (line 5) | fn should_support_repeat_ops_one_dimension() {
  function should_support_float_repeat_repeating_on_many_dimensions (line 21) | fn should_support_float_repeat_repeating_on_many_dimensions() {
  function should_repeat_0_times_empty (line 102) | fn should_repeat_0_times_empty() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/repeat_dim.rs
  function should_support_repeat_ops (line 5) | fn should_support_repeat_ops() {
  function should_support_float_repeat_on_dims_larger_than_1 (line 21) | fn should_support_float_repeat_on_dims_larger_than_1() {
  function repeat_dim_swap_dims_1 (line 54) | fn repeat_dim_swap_dims_1() {
  function repeat_dim_swap_dims_2 (line 92) | fn repeat_dim_swap_dims_2() {
  function repeat_dim_swap_dims_3 (line 134) | fn repeat_dim_swap_dims_3() {
  function should_repeat_dim_0_times_empty (line 160) | fn should_repeat_dim_0_times_empty() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/reshape.rs
  function should_support_rank (line 5) | fn should_support_rank() {
  function should_support_reshape_1d (line 16) | fn should_support_reshape_1d() {
  function should_support_reshape_2d (line 27) | fn should_support_reshape_2d() {
  function should_support_dim_infererence (line 38) | fn should_support_dim_infererence() {
  function should_not_corrupt_after_slice (line 65) | fn should_not_corrupt_after_slice() {
  function multiple_neg_ones (line 78) | fn multiple_neg_ones() {
  function neg_value (line 86) | fn neg_value() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/round.rs
  function should_support_round_ops (line 6) | fn should_support_round_ops() {
  function should_round_ties_even (line 19) | fn should_round_ties_even() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/select.rs
  function should_select_1d (line 5) | fn should_select_1d() {
  function should_select_2d_dim0_same_num_dim (line 17) | fn should_select_2d_dim0_same_num_dim() {
  function should_select_2d_dim0_more_num_dim (line 29) | fn should_select_2d_dim0_more_num_dim() {
  function should_select_2d_dim0_vec (line 46) | fn should_select_2d_dim0_vec() {
  function should_select_2d_dim1 (line 59) | fn should_select_2d_dim1() {
  function should_select_add_1d (line 71) | fn should_select_add_1d() {
  function should_select_add_1d_int (line 84) | fn should_select_add_1d_int() {
  function should_select_add_2d_dim0 (line 97) | fn should_select_add_2d_dim0() {
  function should_select_add_2d_dim1 (line 110) | fn should_select_add_2d_dim1() {
  function should_select_3d_dim1_vec (line 123) | fn should_select_3d_dim1_vec() {
  function should_select_panic_invalid_dimension (line 145) | fn should_select_panic_invalid_dimension() {
  function should_match_default_implementation_behavior (line 154) | fn should_match_default_implementation_behavior() {
  function should_select_with_negative_dim_2d (line 178) | fn should_select_with_negative_dim_2d() {
  function should_select_add_with_negative_dim_2d (line 195) | fn should_select_add_with_negative_dim_2d() {
  function should_panic_select_negative_dim_out_of_bounds (line 216) | fn should_panic_select_negative_dim_out_of_bounds() {
  function should_panic_select_add_negative_dim_out_of_bounds (line 227) | fn should_panic_select_add_negative_dim_out_of_bounds() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/sign.rs
  function should_support_sign_ops_float (line 5) | fn should_support_sign_ops_float() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/slice.rs
  function should_support_slice_dim_1d (line 5) | fn should_support_slice_dim_1d() {
  function should_panic_when_slice_dim_1d_bad_dim (line 25) | fn should_panic_when_slice_dim_1d_bad_dim() {
  function should_support_slice_dim_2d (line 33) | fn should_support_slice_dim_2d() {
  function should_support_slice_dim_with_step (line 44) | fn should_support_slice_dim_with_step() {
  function should_support_slice_dim_with_negative_step (line 63) | fn should_support_slice_dim_with_negative_step() {
  function should_support_full_sliceing_1d (line 75) | fn should_support_full_sliceing_1d() {
  function should_support_full_sliceing_vec (line 85) | fn should_support_full_sliceing_vec() {
  function should_support_partial_sliceing_1d (line 99) | fn should_support_partial_sliceing_1d() {
  function should_support_full_sliceing_2d (line 110) | fn should_support_full_sliceing_2d() {
  function should_support_partial_sliceing_2d (line 122) | fn should_support_partial_sliceing_2d() {
  function should_support_slice_range_first_dim (line 133) | fn should_support_slice_range_first_dim() {
  function should_support_partial_sliceing_3d (line 144) | fn should_support_partial_sliceing_3d() {
  function should_support_partial_sliceing_3d_non_contiguous (line 160) | fn should_support_partial_sliceing_3d_non_contiguous() {
  function should_support_slice_fill_1d (line 176) | fn should_support_slice_fill_1d() {
  function should_support_slice_fill_vec (line 189) | fn should_support_slice_fill_vec() {
  function should_support_slice_fill_cast_f32 (line 204) | fn should_support_slice_fill_cast_f32() {
  function should_support_slice_fill_cast_f64 (line 218) | fn should_support_slice_fill_cast_f64() {
  function should_support_slice_fill_1d_neg (line 230) | fn should_support_slice_fill_1d_neg() {
  function should_support_slice_fill_2d (line 243) | fn should_support_slice_fill_2d() {
  function should_support_slice_fill_with_positive_step (line 256) | fn should_support_slice_fill_with_positive_step() {
  function should_support_slice_fill_with_negative_step (line 288) | fn should_support_slice_fill_with_negative_step() {
  function should_support_slice_fill_with_mixed_steps (line 308) | fn should_support_slice_fill_with_mixed_steps() {
  function clamp_when_slice_exceeds_dimension (line 340) | fn clamp_when_slice_exceeds_dimension() {
  function negative_dimensions (line 349) | fn negative_dimensions() {
  function missing_dimensions (line 367) | fn missing_dimensions() {
  function should_slice_aggregation_result (line 395) | fn should_slice_aggregation_result() {
  function should_panic_when_slice_with_too_many_dimensions (line 404) | fn should_panic_when_slice_with_too_many_dimensions() {
  function should_support_descending_slice_as_empty (line 411) | fn should_support_descending_slice_as_empty() {
  function should_support_empty_slice (line 423) | fn should_support_empty_slice() {
  function should_support_empty_slice_2d (line 436) | fn should_support_empty_slice_2d() {
  function test_slice_with_positive_step (line 451) | fn test_slice_with_positive_step() {
  function test_slice_with_negative_step (line 479) | fn test_slice_with_negative_step() {
  function test_slice_with_mixed_steps (line 520) | fn test_slice_with_mixed_steps() {
  function test_slice_with_steps_1d (line 543) | fn test_slice_with_steps_1d() {
  function test_slice_with_steps_3d (line 565) | fn test_slice_with_steps_3d() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/slice_assign.rs
  function should_support_slice_assign_1d (line 5) | fn should_support_slice_assign_1d() {
  function should_support_slice_assign_2d (line 20) | fn should_support_slice_assign_2d() {
  function should_support_slice_assign_vec (line 35) | fn should_support_slice_assign_vec() {
  function slice_assign_now_supports_non_unit_step (line 52) | fn slice_assign_now_supports_non_unit_step() {
  function test_slice_assign_with_positive_step_1d (line 74) | fn test_slice_assign_with_positive_step_1d() {
  function test_slice_assign_with_positive_step_2d (line 87) | fn test_slice_assign_with_positive_step_2d() {
  function test_slice_assign_with_negative_step_1d (line 145) | fn test_slice_assign_with_negative_step_1d() {
  function test_slice_assign_with_negative_step_2d (line 158) | fn test_slice_assign_with_negative_step_2d() {
  function test_slice_assign_with_mixed_steps (line 205) | fn test_slice_assign_with_mixed_steps() {
  function test_slice_assign_3d_with_steps (line 252) | fn test_slice_assign_3d_with_steps() {
  function test_slice_assign_partial_with_steps (line 302) | fn test_slice_assign_partial_with_steps() {
  function should_support_slice_assign_empty_range (line 329) | fn should_support_slice_assign_empty_range() {
  function should_support_slice_assign_empty_range_1d (line 342) | fn should_support_slice_assign_empty_range_1d() {
  function should_support_slice_assign_single_dim_slice (line 355) | fn should_support_slice_assign_single_dim_slice() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/sort_argsort.rs
  function test_sort_1d_float (line 6) | fn test_sort_1d_float() {
  function test_argsort_1d_float (line 23) | fn test_argsort_1d_float() {
  function test_sort_with_indices_descending_float (line 36) | fn test_sort_with_indices_descending_float() {
  function test_sort_float (line 77) | fn test_sort_float() {
  function test_sort_with_indices_float (line 118) | fn test_sort_with_indices_float() {
  function test_argsort_float (line 167) | fn test_argsort_float() {
  function test_sort_float_nan (line 193) | fn test_sort_float_nan() {
  function test_sort_descending_1d (line 206) | fn test_sort_descending_1d() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/split.rs
  function test_split_evenly_divisible (line 5) | fn test_split_evenly_divisible() {
  function test_split_not_evenly_divisible (line 25) | fn test_split_not_evenly_divisible() {
  function test_split_along_dim1 (line 44) | fn test_split_along_dim1() {
  function test_split_split_size_larger_than_tensor_size (line 62) | fn test_split_split_size_larger_than_tensor_size() {
  function test_split_with_zero_split_size_zero_tensor_size (line 77) | fn test_split_with_zero_split_size_zero_tensor_size() {
  function test_split_zero_sized_tensor (line 87) | fn test_split_zero_sized_tensor() {
  function test_split_with_zero_split_size_non_zero_tensor (line 100) | fn test_split_with_zero_split_size_non_zero_tensor() {
  function test_split_invalid_dim (line 109) | fn test_split_invalid_dim() {
  function test_split_3d_tensor_along_dim0 (line 117) | fn test_split_3d_tensor_along_dim0() {
  function test_split_3d_tensor_along_dim1 (line 143) | fn test_split_3d_tensor_along_dim1() {
  function test_split_with_sizes (line 164) | fn test_split_with_sizes() {
  function test_split_with_sizes_invalid_sum (line 186) | fn test_split_with_sizes_invalid_sum() {
  function test_split_with_sizes_zero_length (line 194) | fn test_split_with_sizes_zero_length() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/sqrt.rs
  function should_support_sqrt_ops (line 7) | fn should_support_sqrt_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/square.rs
  function should_support_sqrt_ops (line 6) | fn should_support_sqrt_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/squeeze.rs
  function should_squeeze_dim (line 6) | fn should_squeeze_dim() {
  function should_squeeze (line 14) | fn should_squeeze() {
  function should_squeeze_first (line 23) | fn should_squeeze_first() {
  function should_squeeze_last (line 31) | fn should_squeeze_last() {
  function should_squeeze_panic (line 40) | fn should_squeeze_panic() {
  function should_squeeze_dims_with_empty_slice (line 47) | fn should_squeeze_dims_with_empty_slice() {
  function should_squeeze_all_dims (line 55) | fn should_squeeze_all_dims() {
  function should_squeeze_dims_with_positive_indices (line 64) | fn should_squeeze_dims_with_positive_indices() {
  function should_squeeze_dims_with_negative_indices (line 73) | fn should_squeeze_dims_with_negative_indices() {
  function should_squeeze_dims_work_if_non_singleton (line 83) | fn should_squeeze_dims_work_if_non_singleton() {
  function should_panic_squeeze_consumes_all_singleton (line 92) | fn should_panic_squeeze_consumes_all_singleton() {
  function should_squeeze_dims_panic_on_too_many_dimensions (line 100) | fn should_squeeze_dims_panic_on_too_many_dimensions() {
  function should_squeeze_dims_dimension_mismatch_panic (line 108) | fn should_squeeze_dims_dimension_mismatch_panic() {
  function should_unsqueeze_dim (line 115) | fn should_unsqueeze_dim() {
  function should_unsqueeze_dim_first (line 124) | fn should_unsqueeze_dim_first() {
  function should_unsqueeze_dim_last (line 133) | fn should_unsqueeze_dim_last() {
  function should_unsqueeze_dim_panic (line 143) | fn should_unsqueeze_dim_panic() {
  function should_unsqueeze_dims_support_dim_inference (line 149) | fn should_unsqueeze_dims_support_dim_inference() {
  function should_unsqueeze_dims_handle_first_last (line 157) | fn should_unsqueeze_dims_handle_first_last() {
  function should_unsqueeze_dims_work_with_single_dim (line 165) | fn should_unsqueeze_dims_work_with_single_dim() {
  function should_unsqueeze_dims_multiple_trailing_negatives (line 174) | fn should_unsqueeze_dims_multiple_trailing_negatives() {
  function should_unsqueeze_dims_panic (line 183) | fn should_unsqueeze_dims_panic() {
  function squeeze_all_singleton_not_supported (line 190) | fn squeeze_all_singleton_not_supported() {
  function squeeze_dim_singleton_not_supported (line 197) | fn squeeze_dim_singleton_not_supported() {
  function squeeze_dims_all_singleton_not_supported (line 204) | fn squeeze_dims_all_singleton_not_supported() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/stack.rs
  function should_support_stack_ops_2d_dim0 (line 6) | fn should_support_stack_ops_2d_dim0() {
  function should_support_stack_ops_2d_dim1 (line 18) | fn should_support_stack_ops_2d_dim1() {
  function should_support_stack_ops_3d (line 30) | fn should_support_stack_ops_3d() {
  function should_panic_when_dimensions_are_not_the_same (line 46) | fn should_panic_when_dimensions_are_not_the_same() {
  function should_panic_when_list_of_vectors_is_empty (line 56) | fn should_panic_when_list_of_vectors_is_empty() {
  function should_panic_when_stack_exceeds_dimension (line 63) | fn should_panic_when_stack_exceeds_dimension() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/sub.rs
  function should_support_sub_ops (line 5) | fn should_support_sub_ops() {
  function test_sub_broadcast (line 19) | fn test_sub_broadcast() {
  function should_support_sub_scalar_ops (line 33) | fn should_support_sub_scalar_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/take.rs
  function should_take_1d (line 5) | fn should_take_1d() {
  function should_take_2d_dim0 (line 18) | fn should_take_2d_dim0() {
  function should_take_2d_dim1 (line 36) | fn should_take_2d_dim1() {
  function take_and_select_should_be_equivalent (line 49) | fn take_and_select_should_be_equivalent() {
  function should_take_with_2d_indices (line 72) | fn should_take_with_2d_indices() {
  function should_take_with_2d_indices_dim1 (line 98) | fn should_take_with_2d_indices_dim1() {
  function should_take_3d_tensor (line 114) | fn should_take_3d_tensor() {
  function should_take_with_3d_indices (line 139) | fn should_take_with_3d_indices() {
  function should_panic_take_invalid_dimension (line 159) | fn should_panic_take_invalid_dimension() {
  function should_take_with_single_index (line 169) | fn should_take_with_single_index() {
  function should_take_with_negative_dim_2d (line 181) | fn should_take_with_negative_dim_2d() {
  function should_panic_take_negative_dim_out_of_bounds (line 199) | fn should_panic_take_negative_dim_out_of_bounds() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/topk.rs
  function test_topk_with_indices_3d (line 6) | fn test_topk_with_indices_3d() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/transaction.rs
  function should_support_transaction (line 6) | fn should_support_transaction() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/transpose.rs
  function should_support_transpose_ops (line 6) | fn should_support_transpose_ops() {
  function should_support_transpose_maybe_fused_with_one (line 29) | fn should_support_transpose_maybe_fused_with_one() {
  function should_support_swap_dims_no_op (line 54) | fn should_support_swap_dims_no_op() {
  function should_support_swap_dims (line 75) | fn should_support_swap_dims() {
  function should_support_swap_dims_neg_index (line 97) | fn should_support_swap_dims_neg_index() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/tri.rs
  function test_triu (line 5) | fn test_triu() {
  function test_triu_positive_diagonal (line 14) | fn test_triu_positive_diagonal() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/trig.rs
  function should_support_cos_ops (line 9) | fn should_support_cos_ops() {
  function should_support_cosh_ops (line 25) | fn should_support_cosh_ops() {
  function should_support_sin_ops (line 38) | fn should_support_sin_ops() {
  function should_support_sinh_ops (line 51) | fn should_support_sinh_ops() {
  function should_support_tan_ops (line 64) | fn should_support_tan_ops() {
  function should_support_tanh_ops (line 77) | fn should_support_tanh_ops() {
  function should_support_asin_ops (line 90) | fn should_support_asin_ops() {
  function should_support_acos_ops (line 103) | fn should_support_acos_ops() {
  function should_support_atan_ops (line 119) | fn should_support_atan_ops() {
  function should_support_asinh_ops (line 132) | fn should_support_asinh_ops() {
  function should_support_acosh_ops (line 145) | fn should_support_acosh_ops() {
  function should_support_atanh_ops (line 158) | fn should_support_atanh_ops() {
  function should_support_atan2_ops (line 171) | fn should_support_atan2_ops() {
  function should_support_deg2rad_ops (line 187) | fn should_support_deg2rad_ops() {
  function should_support_rad2deg_ops (line 216) | fn should_support_rad2deg_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/trunc.rs
  function should_support_trunc_ops (line 6) | fn should_support_trunc_ops() {
  function should_truncate_positive_values_like_floor (line 19) | fn should_truncate_positive_values_like_floor() {
  function should_truncate_negative_values_like_ceil (line 32) | fn should_truncate_negative_values_like_ceil() {
  function should_handle_special_cases (line 45) | fn should_handle_special_cases() {

FILE: crates/burn-backend-tests/tests/tensor/float/ops/unfold.rs
  function test_unfold_float (line 6) | fn test_unfold_float() {

FILE: crates/burn-backend-tests/tests/tensor/float/primitive.rs
  function should_support_float_dtype (line 5) | fn should_support_float_dtype() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/calibration.rs
  function min_max_calibration_range_per_tensor (line 10) | fn min_max_calibration_range_per_tensor() {
  function min_max_calibration_range_per_block (line 27) | fn min_max_calibration_range_per_block() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/data.rs
  function should_support_per_tensor_symmetric_int8 (line 7) | fn should_support_per_tensor_symmetric_int8() {
  function should_support_per_block_symmetric_int8 (line 25) | fn should_support_per_block_symmetric_int8() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/mod.rs
  type QTensor (line 20) | pub struct QTensor<B: Backend, const D: usize> {
  function int8 (line 27) | pub fn int8<F: Into<TensorData>>(floats: F) -> Tensor<B, D> {
  function int8_block (line 32) | pub fn int8_block<F: Into<TensorData>>(floats: F) -> Tensor<B, D> {
  function int8_symmetric (line 41) | pub fn int8_symmetric<F: Into<TensorData>>(floats: F) -> Tensor<B, D> {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/abs.rs
  function should_support_abs_ops (line 7) | fn should_support_abs_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/add.rs
  function test_add_d2 (line 7) | fn test_add_d2() {
  function test_add_broadcast (line 23) | fn test_add_broadcast() {
  function test_add_different_strides_rhs (line 39) | fn test_add_different_strides_rhs() {
  function test_add_different_strides_lhs (line 57) | fn test_add_different_strides_lhs() {
  function test_add_different_strides_broadcast (line 75) | fn test_add_different_strides_broadcast() {
  function should_support_add_scalar_ops (line 93) | fn should_support_add_scalar_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/aggregation.rs
  function test_should_mean (line 7) | fn test_should_mean() {
  function test_should_sum (line 19) | fn test_should_sum() {
  function test_should_mean_last_dim (line 31) | fn test_should_mean_last_dim() {
  function test_should_sum_last_dim (line 44) | fn test_should_sum_last_dim() {
  function test_should_sum_first_dim (line 59) | fn test_should_sum_first_dim() {
  function test_should_mean_first_dim (line 74) | fn test_should_mean_first_dim() {
  function test_should_sum_mid_dim_3d_non_contiguous_1 (line 89) | fn test_should_sum_mid_dim_3d_non_contiguous_1() {
  function test_should_sum_mid_dim_3d_non_contiguous_2 (line 107) | fn test_should_sum_mid_dim_3d_non_contiguous_2() {
  function test_prod_float (line 125) | fn test_prod_float() {
  function test_prod_dim_float (line 145) | fn test_prod_dim_float() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/all.rs
  function test_all (line 6) | fn test_all() {
  function test_all_dim (line 19) | fn test_all_dim() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/any.rs
  function test_any (line 6) | fn test_any() {
  function test_any_dim (line 19) | fn test_any_dim() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/arg.rs
  function test_argmax_2d_dim0 (line 6) | fn test_argmax_2d_dim0() {
  function test_argmin_2d_dim0 (line 17) | fn test_argmin_2d_dim0() {
  function test_argmax_2d_dim1 (line 28) | fn test_argmax_2d_dim1() {
  function test_argmin_2d_dim1 (line 39) | fn test_argmin_2d_dim1() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/cat.rs
  function should_support_cat_ops_2d_dim0 (line 8) | fn should_support_cat_ops_2d_dim0() {
  function should_support_cat_ops_2d_dim1 (line 22) | fn should_support_cat_ops_2d_dim1() {
  function should_support_cat_ops_3d (line 36) | fn should_support_cat_ops_3d() {
  function should_panic_when_dimensions_are_not_the_same (line 51) | fn should_panic_when_dimensions_are_not_the_same() {
  function should_panic_when_cat_exceeds_dimension (line 60) | fn should_panic_when_cat_exceeds_dimension() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/ceil.rs
  function should_support_ceil_ops (line 7) | fn should_support_ceil_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/chunk.rs
  function test_chunk_evenly_divisible (line 8) | fn test_chunk_evenly_divisible() {
  function test_chunk_not_evenly_divisible (line 29) | fn test_chunk_not_evenly_divisible() {
  function test_chunk_not_divisible (line 51) | fn test_chunk_not_divisible() {
  function test_chunk_multi_dimension (line 75) | fn test_chunk_multi_dimension() {
  function test_invalid_dim (line 96) | fn test_invalid_dim() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/clamp.rs
  function clamp_min (line 7) | fn clamp_min() {
  function clamp_max (line 22) | fn clamp_max() {
  function clamp_min_max (line 37) | fn clamp_min_max() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/cos.rs
  function should_support_cos_ops (line 7) | fn should_support_cos_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/cosh.rs
  function should_support_cosh_ops (line 7) | fn should_support_cosh_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/div.rs
  function should_support_div_ops (line 7) | fn should_support_div_ops() {
  function test_div_broadcast (line 21) | fn test_div_broadcast() {
  function should_support_div_scalar_ops (line 37) | fn should_support_div_scalar_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/erf.rs
  function should_support_erf_ops (line 7) | fn should_support_erf_ops() {
  function should_support_erf_ops_with_negative_number (line 20) | fn should_support_erf_ops_with_negative_number() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/exp.rs
  function should_support_exp_ops (line 7) | fn should_support_exp_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/expand.rs
  function expand_2d (line 7) | fn expand_2d() {
  function expand_3d (line 33) | fn expand_3d() {
  function expand_higher_dimensions (line 50) | fn expand_higher_dimensions() {
  function broadcast_single (line 74) | fn broadcast_single() {
  function should_fail_expand_incompatible_shapes (line 87) | fn should_fail_expand_incompatible_shapes() {
  function should_all_negative_one (line 93) | fn should_all_negative_one() {
  function should_panic_negative_one_on_non_existing_dim (line 109) | fn should_panic_negative_one_on_non_existing_dim() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/flip.rs
  function flip_float (line 7) | fn flip_float() {
  function flip_duplicated_axes (line 25) | fn flip_duplicated_axes() {
  function flip_out_of_bound_axis (line 34) | fn flip_out_of_bound_axis() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/floor.rs
  function should_support_floor_ops (line 7) | fn should_support_floor_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/gather_scatter.rs
  function should_gather_1d_dim0 (line 8) | fn should_gather_1d_dim0() {
  function should_gather_2d_dim0 (line 24) | fn should_gather_2d_dim0() {
  function should_gather_2d_dim1 (line 40) | fn should_gather_2d_dim1() {
  function should_gather_3d_dim1 (line 56) | fn should_gather_3d_dim1() {
  function should_gather_2d_only_1dim (line 79) | fn should_gather_2d_only_1dim() {
  function should_scatter_1d (line 95) | fn should_scatter_1d() {
  function should_scatter_2d_dim0 (line 112) | fn should_scatter_2d_dim0() {
  function should_scatter_2d_dim1 (line 129) | fn should_scatter_2d_dim1() {
  function should_scatter_3d_dim1 (line 146) | fn should_scatter_3d_dim1() {
  function should_scatter_2d_dim1_diff_shape (line 174) | fn should_scatter_2d_dim1_diff_shape() {
  function scatter_should_panic_on_mismatch_of_shapes (line 192) | fn scatter_should_panic_on_mismatch_of_shapes() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/log.rs
  function should_support_log_ops (line 7) | fn should_support_log_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/log1p.rs
  function should_support_exp_log1p (line 7) | fn should_support_exp_log1p() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/map_comparison.rs
  function test_equal (line 6) | fn test_equal() {
  function test_not_equal (line 19) | fn test_not_equal() {
  function test_equal_elem (line 33) | fn test_equal_elem() {
  function test_not_equal_elem (line 46) | fn test_not_equal_elem() {
  function test_greater_elem (line 59) | fn test_greater_elem() {
  function test_greater_equal_elem (line 71) | fn test_greater_equal_elem() {
  function test_greater (line 83) | fn test_greater() {
  function test_greater_equal (line 96) | fn test_greater_equal() {
  function test_lower_elem (line 109) | fn test_lower_elem() {
  function test_lower_equal_elem (line 122) | fn test_lower_equal_elem() {
  function test_lower (line 134) | fn test_lower() {
  function test_lower_equal (line 147) | fn test_lower_equal() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/mask.rs
  function should_support_mask_where_ops (line 7) | fn should_support_mask_where_ops() {
  function should_support_mask_fill_ops (line 25) | fn should_support_mask_fill_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/maxmin.rs
  function test_max_dim_2d (line 7) | fn test_max_dim_2d() {
  function test_max_dim_with_indices_2d_with_dim_0th (line 20) | fn test_max_dim_with_indices_2d_with_dim_0th() {
  function test_max_dim_with_indices_2d (line 36) | fn test_max_dim_with_indices_2d() {
  function test_min_dim_2d (line 52) | fn test_min_dim_2d() {
  function test_min_dim_with_indices_2d (line 66) | fn test_min_dim_with_indices_2d() {
  function test_min_dim_2d_with_0th_dim (line 82) | fn test_min_dim_2d_with_0th_dim() {
  function test_max_dim_2d_with_0th_dim (line 95) | fn test_max_dim_2d_with_0th_dim() {
  function test_min_dim_with_indices_2d_with_0th_dim (line 108) | fn test_min_dim_with_indices_2d_with_0th_dim() {
  function test_maximum_pair (line 124) | fn test_maximum_pair() {
  function test_minimum_pair (line 138) | fn test_minimum_pair() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/mul.rs
  function should_support_mul_ops (line 7) | fn should_support_mul_ops() {
  function test_mul_broadcast (line 21) | fn test_mul_broadcast() {
  function test_mul_broadcast_2_dims (line 35) | fn test_mul_broadcast_2_dims() {
  function should_support_mul_scalar_ops (line 49) | fn should_support_mul_scalar_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/narrow.rs
  function test_narrow (line 7) | fn test_narrow() {
  function test_narrow_invalid_dim (line 30) | fn test_narrow_invalid_dim() {
  function test_narrow_invalid_start (line 38) | fn test_narrow_invalid_start() {
  function test_narrow_invalid_zero_length (line 46) | fn test_narrow_invalid_zero_length() {
  function test_narrow_invalid_length (line 54) | fn test_narrow_invalid_length() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/neg.rs
  function should_support_neg_ops (line 7) | fn should_support_neg_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/permute.rs
  function permute_float (line 6) | fn permute_float() {
  function edge_repeated_axes (line 46) | fn edge_repeated_axes() {
  function edge_out_of_bound_axis (line 58) | fn edge_out_of_bound_axis() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/powf.rs
  function should_support_powf_ops (line 7) | fn should_support_powf_ops() {
  function should_support_neg_power (line 21) | fn should_support_neg_power() {
  function should_support_neg_values_with_even_power (line 35) | fn should_support_neg_values_with_even_power() {
  function should_support_neg_values_with_odd_power (line 49) | fn should_support_neg_values_with_odd_power() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/powf_scalar.rs
  function should_support_powf_ops (line 7) | fn should_support_powf_ops() {
  function should_support_neg_power (line 20) | fn should_support_neg_power() {
  function should_support_neg_values_with_even_power (line 33) | fn should_support_neg_values_with_even_power() {
  function should_support_neg_values_with_odd_power (line 46) | fn should_support_neg_values_with_odd_power() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/recip.rs
  function should_support_recip_ops (line 7) | fn should_support_recip_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/remainder.rs
  function should_support_remainder_basic (line 7) | fn should_support_remainder_basic() {
  function should_support_remainder_basic_scalar (line 22) | fn should_support_remainder_basic_scalar() {
  function should_support_remainder_float (line 35) | fn should_support_remainder_float() {
  function should_support_remainder_float_scalar (line 49) | fn should_support_remainder_float_scalar() {
  function should_be_zero (line 62) | fn should_be_zero() {
  function should_be_zero_scalar (line 76) | fn should_be_zero_scalar() {
  function should_have_no_remainder (line 89) | fn should_have_no_remainder() {
  function should_have_no_remainder_scalar (line 103) | fn should_have_no_remainder_scalar() {
  function should_be_negative (line 116) | fn should_be_negative() {
  function should_be_negative_scalar (line 130) | fn should_be_negative_scalar() {
  function should_support_fp_dividends (line 143) | fn should_support_fp_dividends() {
  function should_support_large_divisor (line 156) | fn should_support_large_divisor() {
  function should_support_large_divisor_scalar (line 170) | fn should_support_large_divisor_scalar() {
  function should_support_remainder_op (line 183) | fn should_support_remainder_op() {
  function should_support_remainder_scalar_op (line 198) | fn should_support_remainder_scalar_op() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/repeat_dim.rs
  function should_support_repeat_ops (line 6) | fn should_support_repeat_ops() {
  function should_support_repeat_on_dims_larger_than_1 (line 24) | fn should_support_repeat_on_dims_larger_than_1() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/reshape.rs
  function should_support_reshape_1d (line 6) | fn should_support_reshape_1d() {
  function should_support_reshape_2d (line 19) | fn should_support_reshape_2d() {
  function should_support_dim_infererence (line 32) | fn should_support_dim_infererence() {
  function should_not_corrupt_after_slice (line 56) | fn should_not_corrupt_after_slice() {
  function multiple_neg_ones (line 69) | fn multiple_neg_ones() {
  function neg_value (line 76) | fn neg_value() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/round.rs
  function should_support_round_ops (line 7) | fn should_support_round_ops() {
  function should_round_ties_even (line 20) | fn should_round_ties_even() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/select.rs
  function should_select_1d (line 8) | fn should_select_1d() {
  function should_select_2d_dim0_same_num_dim (line 22) | fn should_select_2d_dim0_same_num_dim() {
  function should_select_2d_dim0_more_num_dim (line 36) | fn should_select_2d_dim0_more_num_dim() {
  function should_select_2d_dim1 (line 55) | fn should_select_2d_dim1() {
  function should_select_assign_1d (line 69) | fn should_select_assign_1d() {
  function should_select_assign_2d_dim0 (line 84) | fn should_select_assign_2d_dim0() {
  function should_select_assign_2d_dim1 (line 99) | fn should_select_assign_2d_dim1() {
  function should_select_panic_invalid_dimension (line 115) | fn should_select_panic_invalid_dimension() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/sin.rs
  function should_support_sin_ops (line 7) | fn should_support_sin_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/sinh.rs
  function should_support_sinh_ops (line 7) | fn should_support_sinh_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/slice.rs
  function should_support_full_sliceing_1d (line 7) | fn should_support_full_sliceing_1d() {
  function should_support_partial_sliceing_1d (line 17) | fn should_support_partial_sliceing_1d() {
  function should_support_full_sliceing_2d (line 30) | fn should_support_full_sliceing_2d() {
  function should_support_partial_sliceing_2d (line 42) | fn should_support_partial_sliceing_2d() {
  function should_support_partial_sliceing_3d (line 55) | fn should_support_partial_sliceing_3d() {
  function should_support_partial_sliceing_3d_non_contiguous (line 71) | fn should_support_partial_sliceing_3d_non_contiguous() {
  function should_support_slice_assign_1d (line 87) | fn should_support_slice_assign_1d() {
  function should_support_slice_assign_2d (line 101) | fn should_support_slice_assign_2d() {
  function slice_should_not_corrupt_potentially_inplace_operations (line 115) | fn slice_should_not_corrupt_potentially_inplace_operations() {
  function slice_assign_should_not_corrupt_potentially_inplace_operations (line 128) | fn slice_assign_should_not_corrupt_potentially_inplace_operations() {
  function clamp_when_slice_exceeds_dimension (line 151) | fn clamp_when_slice_exceeds_dimension() {
  function negative_dimensions (line 160) | fn negative_dimensions() {
  function missing_dimensions (line 184) | fn missing_dimensions() {
  function should_panic_when_slice_with_too_many_dimensions (line 225) | fn should_panic_when_slice_with_too_many_dimensions() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/sort_argsort.rs
  function test_sort_1d_float (line 7) | fn test_sort_1d_float() {
  function test_argsort_1d_float (line 27) | fn test_argsort_1d_float() {
  function test_sort_with_indices_descending_float (line 40) | fn test_sort_with_indices_descending_float() {
  function test_sort_float (line 86) | fn test_sort_float() {
  function test_sort_with_indices_float (line 133) | fn test_sort_with_indices_float() {
  function test_argsort_float (line 188) | fn test_argsort_float() {
  function test_sort_descending_1d (line 214) | fn test_sort_descending_1d() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/split.rs
  function test_split_evenly_divisible (line 8) | fn test_split_evenly_divisible() {
  function test_split_not_evenly_divisible (line 29) | fn test_split_not_evenly_divisible() {
  function test_split_along_dim1 (line 51) | fn test_split_along_dim1() {
  function test_split_split_size_larger_than_tensor_size (line 71) | fn test_split_split_size_larger_than_tensor_size() {
  function test_split_with_zero_split_size_non_zero_tensor (line 91) | fn test_split_with_zero_split_size_non_zero_tensor() {
  function test_split_invalid_dim (line 99) | fn test_split_invalid_dim() {
  function test_split_with_sizes (line 106) | fn test_split_with_sizes() {
  function test_split_with_sizes_invalid_sum (line 130) | fn test_split_with_sizes_invalid_sum() {
  function test_split_with_sizes_zero_length (line 137) | fn test_split_with_sizes_zero_length() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/sqrt.rs
  function should_support_sqrt_ops (line 8) | fn should_support_sqrt_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/stack.rs
  function should_support_stack_ops_2d_dim0 (line 9) | fn should_support_stack_ops_2d_dim0() {
  function should_support_stack_ops_2d_dim1 (line 23) | fn should_support_stack_ops_2d_dim1() {
  function should_support_stack_ops_3d (line 37) | fn should_support_stack_ops_3d() {
  function should_panic_when_dimensions_are_not_the_same (line 55) | fn should_panic_when_dimensions_are_not_the_same() {
  function should_panic_when_stack_exceeds_dimension (line 64) | fn should_panic_when_stack_exceeds_dimension() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/sub.rs
  function should_support_sub_ops (line 7) | fn should_support_sub_ops() {
  function test_sub_broadcast (line 21) | fn test_sub_broadcast() {
  function should_support_sub_scalar_ops (line 35) | fn should_support_sub_scalar_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/tan.rs
  function should_support_tan_ops (line 7) | fn should_support_tan_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/tanh.rs
  function should_support_tanh_ops (line 7) | fn should_support_tanh_ops() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/topk.rs
  function test_topk_1d (line 7) | fn test_topk_1d() {
  function test_topk (line 20) | fn test_topk() {
  function test_topk_with_indices (line 36) | fn test_topk_with_indices() {
  function test_topk_with_indices_3d (line 53) | fn test_topk_with_indices_3d() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/extended/transpose.rs
  function should_support_transpose_ops (line 7) | fn should_support_transpose_ops() {
  function should_support_swap_dims (line 26) | fn should_support_swap_dims() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/matmul.rs
  function test_matmul_vectors (line 8) | fn test_matmul_vectors() {
  function test_matmul_2d (line 22) | fn test_matmul_2d() {
  function test_matmul_2d_aligned (line 34) | fn test_matmul_2d_aligned() {
  function test_matmul_2d_aligned_fused (line 59) | fn test_matmul_2d_aligned_fused() {
  function test_matmul_3d (line 86) | fn test_matmul_3d() {
  function test_matmul_broadcast_4d (line 100) | fn test_matmul_broadcast_4d() {
  function test_matmul_broadcast (line 120) | fn test_matmul_broadcast() {
  function should_panic_when_inner_dimensions_are_not_equal (line 135) | fn should_panic_when_inner_dimensions_are_not_equal() {
  function test_matmul_lhs_float_rhs_quantized (line 144) | fn test_matmul_lhs_float_rhs_quantized() {
  function test_matmul_mixed_block_scale (line 174) | fn test_matmul_mixed_block_scale() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/ops/quantize.rs
  function get_q_params (line 10) | fn get_q_params(data: TensorData) -> QParams<Vec<f32>> {
  function should_support_quantize_symmetric_int8 (line 26) | fn should_support_quantize_symmetric_int8() {
  function should_support_quantize_dynamic_int8 (line 66) | fn should_support_quantize_dynamic_int8() {
  function should_quantize_dequantize_symmetric_single_with_transform (line 86) | fn should_quantize_dequantize_symmetric_single_with_transform() {
  function should_quantize_dequantize_symmetric_arange_16x16 (line 104) | fn should_quantize_dequantize_symmetric_arange_16x16() {
  function should_quantize_dequantize_symmetric_per_block_arange_16x16 (line 122) | fn should_quantize_dequantize_symmetric_per_block_arange_16x16() {
  function should_quantize_transposed (line 141) | fn should_quantize_transposed<const D: usize>(tensor: Tensor<TestBackend...
  function should_quantize_symmetric_int8_transposed_8x32 (line 153) | fn should_quantize_symmetric_int8_transposed_8x32() {
  function should_quantize_symmetric_int8_transposed_48x64 (line 164) | fn should_quantize_symmetric_int8_transposed_48x64() {
  function should_quantize_symmetric_per_block_int8_transposed_32x64 (line 175) | fn should_quantize_symmetric_per_block_int8_transposed_32x64() {
  function should_quantize_symmetric_int8_permuted_batch_dims (line 188) | fn should_quantize_symmetric_int8_permuted_batch_dims() {

FILE: crates/burn-backend-tests/tests/tensor/float/quantization/scheme.rs
  function per_tensor_symmetric_int8 (line 10) | fn per_tensor_symmetric_int8() {
  function per_block_symmetric_int8 (line 27) | fn per_block_symmetric_int8() {
  function quant_scheme_should_inhibit_by_default (line 46) | fn quant_scheme_should_inhibit_by_default() {

FILE: crates/burn-backend-tests/tests/tensor/float/stats/cov.rs
  function test_cov_1 (line 5) | fn test_cov_1() {
  function test_cov_4 (line 20) | fn test_cov_4() {
  function test_cov_2 (line 34) | fn test_cov_2() {
  function test_cov_3 (line 54) | fn test_cov_3() {

FILE: crates/burn-backend-tests/tests/tensor/float/stats/display.rs
  type FloatElem (line 5) | type FloatElem = <TestBackend as Backend>::FloatElem;
  type IntElem (line 6) | type IntElem = <TestBackend as Backend>::IntElem;
  function skip_precision_not_f32 (line 9) | fn skip_precision_not_f32() -> bool {
  function test_display_2d_int_tensor (line 14) | fn test_display_2d_int_tensor() {
  function test_display_2d_float_tensor (line 39) | fn test_display_2d_float_tensor() {
  function test_display_2d_bool_tensor (line 67) | fn test_display_2d_bool_tensor() {
  function test_display_3d_tensor (line 102) | fn test_display_3d_tensor() {
  function test_display_4d_tensor (line 133) | fn test_display_4d_tensor() {
  function test_display_tensor_summarize_1 (line 167) | fn test_display_tensor_summarize_1() {
  function test_display_tensor_summarize_2 (line 196) | fn test_display_tensor_summarize_2() {
  function test_display_tensor_summarize_3 (line 245) | fn test_display_tensor_summarize_3() {
  function test_display_precision (line 293) | fn test_display_precision() {

FILE: crates/burn-backend-tests/tests/tensor/float/stats/eye.rs
  function test_eye_float (line 4) | fn test_eye_float() {
  function test_eye_int (line 12) | fn test_eye_int() {

FILE: crates/burn-backend-tests/tests/tensor/float/stats/median.rs
  function test_median_even (line 5) | fn test_median_even() {
  function test_median_odd (line 25) | fn test_median_odd() {
  function test_median_with_indices (line 49) | fn test_median_with_indices() {
  function test_median_all_elements (line 75) | fn test_median_all_elements() {

FILE: crates/burn-backend-tests/tests/tensor/float/stats/var.rs
  function test_var (line 6) | fn test_var() {
  function test_var_mean (line 21) | fn test_var_mean() {
  function test_var_bias (line 39) | fn test_var_bias() {
  function test_var_mean_bias (line 54) | fn test_var_mean_bias() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/abs.rs
  function should_support_abs_ops_int (line 5) | fn should_support_abs_ops_int() {
  function should_support_abs_ops_int_signed_min (line 16) | fn should_support_abs_ops_int_signed_min() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/add.rs
  function test_add_d2_int (line 5) | fn test_add_d2_int() {
  function test_add_broadcast_int (line 17) | fn test_add_broadcast_int() {
  function should_support_add_scalar_ops_int (line 29) | fn should_support_add_scalar_ops_int() {
  function scalar_add_not_contiguous (line 41) | fn scalar_add_not_contiguous() {
  function scalar_add_not_contiguous_int (line 56) | fn scalar_add_not_contiguous_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/aggregation.rs
  function test_should_mean_int (line 5) | fn test_should_mean_int() {
  function test_should_mean_last_dim_int (line 14) | fn test_should_mean_last_dim_int() {
  function test_should_sum_last_dim_int (line 25) | fn test_should_sum_last_dim_int() {
  function test_should_sum_int (line 36) | fn test_should_sum_int() {
  function test_prod_int (line 46) | fn test_prod_int() {
  function test_prod_dim_int (line 62) | fn test_prod_dim_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/all.rs
  function test_all (line 5) | fn test_all() {
  function test_all_dim (line 18) | fn test_all_dim() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/any.rs
  function test_any (line 5) | fn test_any() {
  function test_any_dim (line 18) | fn test_any_dim() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/arange.rs
  function test_arange (line 6) | fn test_arange() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/arange_step.rs
  function test_arange_step (line 6) | fn test_arange_step() {
  function should_panic_when_step_is_zero (line 41) | fn should_panic_when_step_is_zero() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/arg.rs
  function test_argmax_2d_dim0_int (line 5) | fn test_argmax_2d_dim0_int() {
  function test_argmin_2d_dim0_int (line 16) | fn test_argmin_2d_dim0_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/bitwise.rs
  function should_apply_bitwise_and_2d (line 5) | fn should_apply_bitwise_and_2d() {
  function should_apply_bitwise_and_1d (line 17) | fn should_apply_bitwise_and_1d() {
  function should_apply_bitwise_and_scalar_2d (line 29) | fn should_apply_bitwise_and_scalar_2d() {
  function should_apply_bitwise_not_2d (line 41) | fn should_apply_bitwise_not_2d() {
  function should_apply_bitwise_or_scalar_2d (line 52) | fn should_apply_bitwise_or_scalar_2d() {
  function should_apply_bitwise_or_2d (line 64) | fn should_apply_bitwise_or_2d() {
  function should_apply_bitwise_or_1d (line 76) | fn should_apply_bitwise_or_1d() {
  function should_apply_bitwise_xor_scalar_2d (line 88) | fn should_apply_bitwise_xor_scalar_2d() {
  function should_apply_bitwise_xor_2d (line 100) | fn should_apply_bitwise_xor_2d() {
  function should_apply_bitwise_xor_1d (line 112) | fn should_apply_bitwise_xor_1d() {
  function should_apply_bitwise_left_shift_2d (line 124) | fn should_apply_bitwise_left_shift_2d() {
  function should_apply_bitwise_left_shift_scalar_2d (line 140) | fn should_apply_bitwise_left_shift_scalar_2d() {
  function should_apply_bitwise_right_shift_2d (line 152) | fn should_apply_bitwise_right_shift_2d() {
  function should_apply_bitwise_right_shift_scalar_2d (line 164) | fn should_apply_bitwise_right_shift_scalar_2d() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/cartesian_grid.rs
  function test_cartesian_grid (line 6) | fn test_cartesian_grid() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/cast.rs
  function cast_int_to_bool (line 5) | fn cast_int_to_bool() {
  function cast_bool_to_int_tensor (line 13) | fn cast_bool_to_int_tensor() {
  function cast_int_precision (line 22) | fn cast_int_precision() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/cat.rs
  function should_support_cat_ops_int (line 5) | fn should_support_cat_ops_int() {
  function should_support_cat_with_empty_tensor_int (line 18) | fn should_support_cat_with_empty_tensor_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/chunk.rs
  function test_chunk_multi_dimension (line 5) | fn test_chunk_multi_dimension() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/comparison.rs
  function test_equal (line 5) | fn test_equal() {
  function test_not_equal (line 18) | fn test_not_equal() {
  function test_equal_elem (line 31) | fn test_equal_elem() {
  function test_not_equal_elem (line 43) | fn test_not_equal_elem() {
  function greater_elem (line 55) | fn greater_elem() {
  function test_greater_equal_elem (line 67) | fn test_greater_equal_elem() {
  function test_greater (line 79) | fn test_greater() {
  function test_greater_equal (line 92) | fn test_greater_equal() {
  function test_lower_elem (line 105) | fn test_lower_elem() {
  function test_lower_equal_elem (line 117) | fn test_lower_equal_elem() {
  function test_lower (line 129) | fn test_lower() {
  function test_lower_equal (line 142) | fn test_lower_equal() {
  function test_greater_broadcast (line 155) | fn test_greater_broadcast() {
  function test_greater_equal_broadcast (line 180) | fn test_greater_equal_broadcast() {
  function test_equal_broadcast (line 200) | fn test_equal_broadcast() {
  function test_not_equal_broadcast (line 219) | fn test_not_equal_broadcast() {
  function test_int_greater_broadcast (line 238) | fn test_int_greater_broadcast() {
  function test_int_lower_equal_broadcast (line 256) | fn test_int_lower_equal_broadcast() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/create_like.rs
  function should_support_zeros_like (line 5) | fn should_support_zeros_like() {
  function should_support_ones_like (line 15) | fn should_support_ones_like() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/cumulative.rs
  function test_cumsum_int_dim_0 (line 5) | fn test_cumsum_int_dim_0() {
  function test_cumsum_int_dim_1 (line 16) | fn test_cumsum_int_dim_1() {
  function test_cumprod_int_dim_0 (line 27) | fn test_cumprod_int_dim_0() {
  function test_cumprod_int_dim_1 (line 38) | fn test_cumprod_int_dim_1() {
  function test_cummin_int_dim_0 (line 49) | fn test_cummin_int_dim_0() {
  function test_cummin_int_dim_1 (line 60) | fn test_cummin_int_dim_1() {
  function test_cummax_int_dim_0 (line 71) | fn test_cummax_int_dim_0() {
  function test_cummax_int_dim_1 (line 82) | fn test_cummax_int_dim_1() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/div.rs
  function should_support_div_ops_int (line 5) | fn should_support_div_ops_int() {
  function test_div_broadcast_int (line 20) | fn test_div_broadcast_int() {
  function should_support_div_scalar_ops_int (line 35) | fn should_support_div_scalar_ops_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/expand.rs
  function expand_2d_int (line 5) | fn expand_2d_int() {
  function should_all_negative_one (line 15) | fn should_all_negative_one() {
  function should_panic_negative_one_on_non_existing_dim (line 26) | fn should_panic_negative_one_on_non_existing_dim() {
  function inplace_op_after_expand (line 33) | fn inplace_op_after_expand() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/flip.rs
  function flip_int (line 5) | fn flip_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/full.rs
  function test_tensor_full (line 5) | fn test_tensor_full() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/gather_scatter.rs
  function should_gather_1d_dim0_int (line 5) | fn should_gather_1d_dim0_int() {
  function should_gather_indices_broadcasted (line 18) | fn should_gather_indices_broadcasted() {
  function should_scatter_add_1d_int (line 58) | fn should_scatter_add_1d_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/init.rs
  function should_support_int_empty (line 5) | fn should_support_int_empty() {
  function should_support_int_zeros (line 12) | fn should_support_int_zeros() {
  function should_support_int_ones (line 23) | fn should_support_int_ones() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/mask.rs
  function should_support_mask_where_broadcast_int (line 5) | fn should_support_mask_where_broadcast_int() {
  function should_support_int_mask_where_ops (line 32) | fn should_support_int_mask_where_ops() {
  function should_support_int_mask_fill_ops (line 46) | fn should_support_int_mask_fill_ops() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/matmul.rs
  function test_int_matmul_d2 (line 5) | fn test_int_matmul_d2() {
  function test_int_matmul_d3 (line 17) | fn test_int_matmul_d3() {
  function test_int_matmul_broadcast_1 (line 29) | fn test_int_matmul_broadcast_1() {
  function test_int_matmul_broadcast_4d (line 41) | fn test_int_matmul_broadcast_4d() {
  function test_int_matmul_simple_1 (line 59) | fn test_int_matmul_simple_1() {
  function test_int_matmul_4_3 (line 71) | fn test_int_matmul_4_3() {
  function test_int_matmul_trivial (line 89) | fn test_int_matmul_trivial() {
  function test_int_matmul_trivial_transposed (line 112) | fn test_int_matmul_trivial_transposed() {
  function test_int_matmul_4_8 (line 135) | fn test_int_matmul_4_8() {
  function test_int_matmul_simple_2 (line 158) | fn test_int_matmul_simple_2() {
  function test_int_matmul_simple_3 (line 170) | fn test_int_matmul_simple_3() {
  function int_should_panic_when_inner_dimensions_are_not_equal (line 189) | fn int_should_panic_when_inner_dimensions_are_not_equal() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/movedim.rs
  function movedim_int (line 5) | fn movedim_int() {
  function vec_input_int (line 30) | fn vec_input_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/mul.rs
  function should_support_mul_ops_int (line 5) | fn should_support_mul_ops_int() {
  function test_mul_broadcast_int (line 19) | fn test_mul_broadcast_int() {
  function should_support_mul_scalar_ops_int (line 33) | fn should_support_mul_scalar_ops_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/one_hot.rs
  function int_should_support_one_hot (line 5) | fn int_should_support_one_hot() {
  function int_one_hot_should_panic_when_index_exceeds_number_of_classes (line 14) | fn int_one_hot_should_panic_when_index_exceeds_number_of_classes() {
  function int_one_hot_should_panic_when_number_of_classes_is_zero (line 21) | fn int_one_hot_should_panic_when_number_of_classes_is_zero() {
  function one_hot_fill_with_positive_axis_and_indices (line 27) | fn one_hot_fill_with_positive_axis_and_indices() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/permute.rs
  function permute_int (line 5) | fn permute_int() {
  function edge_repeated_axes (line 33) | fn edge_repeated_axes() {
  function edge_out_of_bound_axis (line 43) | fn edge_out_of_bound_axis() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/random.rs
  function rand_uniform_int (line 5) | fn rand_uniform_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/remainder.rs
  function should_support_int_remainder_basic (line 5) | fn should_support_int_remainder_basic() {
  function should_support_int_remainder_basic_scalar (line 18) | fn should_support_int_remainder_basic_scalar() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/repeat.rs
  function should_support_int_repeat_ops_one_dimension (line 5) | fn should_support_int_repeat_ops_one_dimension() {
  function should_support_int_repeat_on_many_dims (line 21) | fn should_support_int_repeat_on_many_dims() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/repeat_dim.rs
  function should_support_int_repeat_ops (line 5) | fn should_support_int_repeat_ops() {
  function should_support_int_repeat_on_dims_larger_than_1 (line 16) | fn should_support_int_repeat_on_dims_larger_than_1() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/reshape.rs
  function should_support_reshape_maybe_fused_1 (line 5) | fn should_support_reshape_maybe_fused_1() {
  function should_support_reshape_maybe_fused_2 (line 65) | fn should_support_reshape_maybe_fused_2() {
  function should_support_reshape_maybe_fused_3 (line 77) | fn should_support_reshape_maybe_fused_3() {
  function should_support_reshape_maybe_fused_4 (line 87) | fn should_support_reshape_maybe_fused_4() {
  function should_support_reshape_maybe_fused_5 (line 100) | fn should_support_reshape_maybe_fused_5() {
  function should_support_reshape_maybe_fused_6 (line 114) | fn should_support_reshape_maybe_fused_6() {
  function should_support_multiple_reshapes_cloned_tensor (line 150) | fn should_support_multiple_reshapes_cloned_tensor() {
  function should_support_reshape_int (line 171) | fn should_support_reshape_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/roll.rs
  function test_roll_empty (line 6) | fn test_roll_empty() {
  function test_roll (line 19) | fn test_roll() {
  function test_roll_dim_too_big (line 50) | fn test_roll_dim_too_big() {
  function test_roll_dim_too_small (line 59) | fn test_roll_dim_too_small() {
  function test_roll_shift_size_mismatch (line 68) | fn test_roll_shift_size_mismatch() {
  function test_roll_dim (line 76) | fn test_roll_dim() {
  function test_roll_dim_dim_too_big (line 94) | fn test_roll_dim_dim_too_big() {
  function test_roll_dim_dim_too_small (line 103) | fn test_roll_dim_dim_too_small() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/select.rs
  function should_select_1d_int (line 5) | fn should_select_1d_int() {
  function should_select_add_1d_int (line 17) | fn should_select_add_1d_int() {
  function should_panic_select_add_invalid_num_indices (line 31) | fn should_panic_select_add_invalid_num_indices() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/sign.rs
  function should_support_sign_ops_int (line 5) | fn should_support_sign_ops_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/slice.rs
  function slice_should_not_corrupt_potentially_inplace_operations (line 5) | fn slice_should_not_corrupt_potentially_inplace_operations() {
  function test_slice_int_tensor_with_steps (line 15) | fn test_slice_int_tensor_with_steps() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/slice_assign.rs
  function slice_assign_should_not_corrupt_potentially_inplace_operations (line 5) | fn slice_assign_should_not_corrupt_potentially_inplace_operations() {
  function test_slice_assign_int_tensor_with_steps (line 22) | fn test_slice_assign_int_tensor_with_steps() {
  function should_support_slice_assign_empty_range_int (line 45) | fn should_support_slice_assign_empty_range_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/sort_argsort.rs
  function test_sort_1d_int (line 5) | fn test_sort_1d_int() {
  function test_argsort_1d_int (line 21) | fn test_argsort_1d_int() {
  function test_sort_with_indices_descending_int (line 37) | fn test_sort_with_indices_descending_int() {
  function test_sort_int (line 67) | fn test_sort_int() {
  function test_sort_with_indices_int (line 90) | fn test_sort_with_indices_int() {
  function test_argsort_int (line 122) | fn test_argsort_int() {
  function test_sort_descending_1d (line 145) | fn test_sort_descending_1d() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/stack.rs
  function should_support_stack_ops_int (line 6) | fn should_support_stack_ops_int() {
  function should_generate_row_major_layout (line 18) | fn should_generate_row_major_layout() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/sub.rs
  function should_support_sub_ops_int (line 5) | fn should_support_sub_ops_int() {
  function test_sub_broadcast_int (line 19) | fn test_sub_broadcast_int() {
  function should_support_sub_scalar_ops_int (line 33) | fn should_support_sub_scalar_ops_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/take.rs
  function should_take_int_tensor (line 5) | fn should_take_int_tensor() {
  function should_take_int_tensor_with_2d_indices (line 18) | fn should_take_int_tensor_with_2d_indices() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/topk.rs
  function test_topk_1d (line 6) | fn test_topk_1d() {
  function test_topk (line 27) | fn test_topk() {
  function test_topk_with_indices_1d (line 49) | fn test_topk_with_indices_1d() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/transpose.rs
  function should_support_transpose_ops_int (line 5) | fn should_support_transpose_ops_int() {
  function should_support_swap_dims_int (line 18) | fn should_support_swap_dims_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/tri.rs
  function test_triu_negative_diagonal (line 5) | fn test_triu_negative_diagonal() {
  function test_triu_batch_tensors (line 15) | fn test_triu_batch_tensors() {
  function test_triu_too_few_dims (line 31) | fn test_triu_too_few_dims() {
  function test_tril (line 37) | fn test_tril() {
  function test_tril_positive_diagonal (line 46) | fn test_tril_positive_diagonal() {
  function test_tril_negative_diagonal (line 56) | fn test_tril_negative_diagonal() {
  function test_tril_batch_tensors (line 66) | fn test_tril_batch_tensors() {
  function test_tril_too_few_dims (line 82) | fn test_tril_too_few_dims() {

FILE: crates/burn-backend-tests/tests/tensor/int/ops/unfold.rs
  function test_unfold_int (line 6) | fn test_unfold_int() {

FILE: crates/burn-backend-tests/tests/tensor/int/primitive.rs
  function should_support_int_dtype (line 5) | fn should_support_int_dtype() {

FILE: crates/burn-backend-tests/tests/tensor/multi_threads.rs
  type MultiThreadTestSettings (line 8) | struct MultiThreadTestSettings {
  function should_handle_multi_threads_dropped (line 24) | fn should_handle_multi_threads_dropped() {
  function should_handle_multi_threads_consumed (line 37) | fn should_handle_multi_threads_consumed() {
  function should_handle_multi_threads_drop_no_wait (line 50) | fn should_handle_multi_threads_drop_no_wait() {
  function should_handle_multi_threads_consumed_no_wait (line 63) | fn should_handle_multi_threads_consumed_no_wait() {
  function should_handle_multi_threads_no_async_op (line 76) | fn should_handle_multi_threads_no_async_op() {
  function should_handle_multi_threads_no_async_op_no_wait (line 92) | fn should_handle_multi_threads_no_async_op_no_wait() {
  function run_multi_thread_test (line 104) | fn run_multi_thread_test(settings: MultiThreadTestSettings) {

FILE: crates/burn-backend/src/backend/base.rs
  type Backend (line 65) | pub trait Backend:
    method ad_enabled (line 103) | fn ad_enabled(_device: &Self::Device) -> bool {
    method memory_persistent_allocations (line 109) | fn memory_persistent_allocations<
    method memory_cleanup (line 123) | fn memory_cleanup(device: &Self::Device) {}
    method name (line 126) | fn name(device: &Self::Device) -> String;
    method seed (line 134) | fn seed(device: &Self::Device, seed: u64);
    method sync (line 137) | fn sync(_device: &Self::Device) -> Result<(), ExecutionError> {
    method staging (line 146) | fn staging<'a, Iter>(_data: Iter, _device: &Self::Device)
    method supports_dtype (line 161) | fn supports_dtype(device: &Self::Device, dtype: DType) -> bool {
    method dtype_usage (line 166) | fn dtype_usage(device: &Self::Device, dtype: DType) -> DTypeUsageSet;
  type ExecutionError (line 171) | pub enum ExecutionError {
    method fmt (line 194) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type AutodiffBackend (line 200) | pub trait AutodiffBackend: Backend {
    method backward (line 216) | fn backward(tensor: FloatTensor<Self>) -> Self::Gradients;
    method grad (line 227) | fn grad(
    method grad_remove (line 242) | fn grad_remove(
    method grad_replace (line 256) | fn grad_replace(
    method inner (line 271) | fn inner(tensor: FloatTensor<Self>) -> FloatTensor<Self::InnerBackend>;
    method int_inner (line 282) | fn int_inner(tensor: IntTensor<Self>) -> IntTensor<Self::InnerBackend>;
    method bool_inner (line 293) | fn bool_inner(tensor: BoolTensor<Self>) -> BoolTensor<Self::InnerBacke...
    method q_inner (line 304) | fn q_inner(tensor: QuantizedTensor<Self>) -> QuantizedTensor<Self::Inn...
    method from_inner (line 316) | fn from_inner(tensor: FloatTensor<Self::InnerBackend>) -> FloatTensor<...
    method int_from_inner (line 328) | fn int_from_inner(tensor: IntTensor<Self::InnerBackend>) -> IntTensor<...
    method bool_from_inner (line 340) | fn bool_from_inner(tensor: BoolTensor<Self::InnerBackend>) -> BoolTens...
    method q_from_inner (line 352) | fn q_from_inner(tensor: QuantizedTensor<Self::InnerBackend>) -> Quanti...
  type DTypeUsage (line 361) | pub enum DTypeUsage {
    method general (line 392) | pub fn general() -> DTypeUsageSet {
  type DTypeUsageSet (line 388) | pub type DTypeUsageSet = EnumSet<DTypeUsage>;

FILE: crates/burn-backend/src/backend/device.rs
  type DeviceOps (line 4) | pub trait DeviceOps: Clone + Default + PartialEq + Send + Sync + core::f...
    method id (line 6) | fn id(&self) -> DeviceId {
    method inner (line 14) | fn inner(&self) -> &Self {

FILE: crates/burn-backend/src/backend/ops/activation.rs
  type ActivationOps (line 8) | pub trait ActivationOps<B: Backend> {
    method leaky_relu (line 19) | fn leaky_relu(tensor: FloatTensor<B>, negative_slope: Scalar) -> Float...
    method relu (line 36) | fn relu(tensor: FloatTensor<B>) -> FloatTensor<B> {
    method relu_backward (line 51) | fn relu_backward(output: FloatTensor<B>, grad: FloatTensor<B>) -> Floa...
    method gelu (line 66) | fn gelu(tensor: FloatTensor<B>) -> FloatTensor<B> {
    method prelu (line 78) | fn prelu(tensor: FloatTensor<B>, alpha: FloatTensor<B>) -> FloatTensor...
    method gelu_backward (line 94) | fn gelu_backward(x: FloatTensor<B>, grad: FloatTensor<B>) -> FloatTens...
    method sigmoid (line 135) | fn sigmoid(tensor: FloatTensor<B>) -> FloatTensor<B> {
    method sigmoid_backward (line 156) | fn sigmoid_backward(output: FloatTensor<B>, grad: FloatTensor<B>) -> F...
    method hard_sigmoid (line 175) | fn hard_sigmoid(tensor: FloatTensor<B>, alpha: Scalar, beta: Scalar) -...
    method log_sigmoid (line 197) | fn log_sigmoid(tensor: FloatTensor<B>) -> FloatTensor<B> {
    method log_sigmoid_backward (line 241) | fn log_sigmoid_backward(x: FloatTensor<B>, grad: FloatTensor<B>) -> Fl...

FILE: crates/burn-backend/src/backend/ops/argwhere.rs
  function argwhere_data (line 23) | pub fn argwhere_data<B: Backend>(data: TensorData, device: &Device<B>) -...

FILE: crates/burn-backend/src/backend/ops/bool_tensor.rs
  type BoolTensorOps (line 15) | pub trait BoolTensorOps<B: Backend> {
    method bool_empty (line 26) | fn bool_empty(shape: Shape, device: &Device<B>) -> BoolTensor<B>;
    method bool_zeros (line 38) | fn bool_zeros(shape: Shape, device: &Device<B>) -> BoolTensor<B>;
    method bool_ones (line 50) | fn bool_ones(shape: Shape, device: &Device<B>) -> BoolTensor<B>;
    method bool_into_data (line 61) | fn bool_into_data(
    method bool_from_data (line 75) | fn bool_from_data(data: TensorData, device: &Device<B>) -> BoolTensor<B>;
    method bool_into_int (line 86) | fn bool_into_int(tensor: BoolTensor<B>) -> IntTensor<B>;
    method bool_into_float (line 97) | fn bool_into_float(tensor: BoolTensor<B>) -> FloatTensor<B>;
    method bool_device (line 108) | fn bool_device(tensor: &BoolTensor<B>) -> Device<B>;
    method bool_to_device (line 111) | fn bool_to_device(tensor: BoolTensor<B>, device: &Device<B>) -> BoolTe...
    method bool_reshape (line 123) | fn bool_reshape(tensor: BoolTensor<B>, shape: Shape) -> BoolTensor<B>;
    method bool_slice (line 140) | fn bool_slice(tensor: BoolTensor<B>, slices: &[Slice]) -> BoolTensor<B>;
    method bool_slice_assign (line 159) | fn bool_slice_assign(
    method bool_mask_where (line 177) | fn bool_mask_where(
    method bool_mask_fill (line 194) | fn bool_mask_fill(tensor: BoolTensor<B>, mask: BoolTensor<B>, value: S...
    method bool_gather (line 203) | fn bool_gather(dim: usize, tensor: BoolTensor<B>, indices: IntTensor<B...
    method bool_scatter_or (line 217) | fn bool_scatter_or(
    method bool_select (line 235) | fn bool_select(tensor: BoolTensor<B>, dim: usize, indices: IntTensor<B...
    method bool_select_or (line 255) | fn bool_select_or(
    method bool_repeat_dim (line 280) | fn bool_repeat_dim(tensor: BoolTensor<B>, dim: usize, times: usize) ->...
    method bool_cat (line 300) | fn bool_cat(tensors: Vec<BoolTensor<B>>, dim: usize) -> BoolTensor<B> {
    method bool_equal (line 314) | fn bool_equal(lhs: BoolTensor<B>, rhs: BoolTensor<B>) -> BoolTensor<B>;
    method bool_not_equal (line 326) | fn bool_not_equal(lhs: BoolTensor<B>, rhs: BoolTensor<B>) -> BoolTenso...
    method bool_equal_elem (line 341) | fn bool_equal_elem(lhs: BoolTensor<B>, rhs: Scalar) -> BoolTensor<B>;
    method bool_not_equal_elem (line 353) | fn bool_not_equal_elem(lhs: BoolTensor<B>, rhs: Scalar) -> BoolTensor<...
    method bool_not (line 367) | fn bool_not(tensor: BoolTensor<B>) -> BoolTensor<B>;
    method bool_and (line 379) | fn bool_and(lhs: BoolTensor<B>, rhs: BoolTensor<B>) -> BoolTensor<B>;
    method bool_or (line 391) | fn bool_or(lhs: BoolTensor<B>, rhs: BoolTensor<B>) -> BoolTensor<B>;
    method bool_xor (line 403) | fn bool_xor(lhs: BoolTensor<B>, rhs: BoolTensor<B>) -> BoolTensor<B> {
    method bool_transpose (line 416) | fn bool_transpose(tensor: BoolTensor<B>) -> BoolTensor<B> {
    method bool_swap_dims (line 432) | fn bool_swap_dims(tensor: BoolTensor<B>, dim1: usize, dim2: usize) -> ...
    method bool_permute (line 443) | fn bool_permute(tensor: BoolTensor<B>, axes: &[usize]) -> BoolTensor<B>;
    method bool_flip (line 453) | fn bool_flip(tensor: BoolTensor<B>, axes: &[usize]) -> BoolTensor<B>;
    method bool_any (line 464) | fn bool_any(tensor: BoolTensor<B>) -> BoolTensor<B> {
    method bool_any_dim (line 481) | fn bool_any_dim(tensor: BoolTensor<B>, dim: usize) -> BoolTensor<B> {
    method bool_all (line 496) | fn bool_all(tensor: BoolTensor<B>) -> BoolTensor<B> {
    method bool_all_dim (line 514) | fn bool_all_dim(tensor: BoolTensor<B>, dim: usize) -> BoolTensor<B> {
    method bool_argwhere (line 530) | fn bool_argwhere(tensor: BoolTensor<B>) -> impl Future<Output = IntTen...
    method bool_expand (line 543) | fn bool_expand(tensor: BoolTensor<B>, shape: Shape) -> BoolTensor<B>;
    method bool_unfold (line 562) | fn bool_unfold(tensor: BoolTensor<B>, dim: usize, size: usize, step: u...

FILE: crates/burn-backend/src/backend/ops/cat.rs
  function cat_with_slice_assign (line 8) | pub(crate) fn cat_with_slice_assign<B: Backend, K: TensorKind<B> + Basic...

FILE: crates/burn-backend/src/backend/ops/int_tensor.rs
  type IntTensorOps (line 15) | pub trait IntTensorOps<B: Backend> {
    method int_empty (line 27) | fn int_empty(shape: Shape, device: &Device<B>, dtype: IntDType) -> Int...
    method int_into_data (line 38) | fn int_into_data(
    method int_from_data (line 52) | fn int_from_data(data: TensorData, device: &Device<B>) -> IntTensor<B>;
    method int_device (line 63) | fn int_device(tensor: &IntTensor<B>) -> Device<B>;
    method int_to_device (line 66) | fn int_to_device(tensor: IntTensor<B>, device: &Device<B>) -> IntTenso...
    method int_reshape (line 78) | fn int_reshape(tensor: IntTensor<B>, shape: Shape) -> IntTensor<B>;
    method int_slice (line 95) | fn int_slice(tensor: IntTensor<B>, slices: &[Slice]) -> IntTensor<B>;
    method int_slice_assign (line 113) | fn int_slice_assign(
    method int_into_float (line 128) | fn int_into_float(tensor: IntTensor<B>) -> FloatTensor<B>;
    method int_mask_where (line 142) | fn int_mask_where(
    method int_mask_fill (line 159) | fn int_mask_fill(tensor: IntTensor<B>, mask: BoolTensor<B>, value: Sca...
    method int_gather (line 168) | fn int_gather(dim: usize, tensor: IntTensor<B>, indices: IntTensor<B>)...
    method int_scatter_add (line 182) | fn int_scatter_add(
    method int_select (line 200) | fn int_select(tensor: IntTensor<B>, dim: usize, indices: IntTensor<B>)...
    method int_select_add (line 215) | fn int_select_add(
    method int_repeat_dim (line 233) | fn int_repeat_dim(tensor: IntTensor<B>, dim: usize, times: usize) -> I...
    method int_cat (line 253) | fn int_cat(tensors: Vec<IntTensor<B>>, dim: usize) -> IntTensor<B> {
    method int_equal (line 267) | fn int_equal(lhs: IntTensor<B>, rhs: IntTensor<B>) -> BoolTensor<B>;
    method int_not_equal (line 279) | fn int_not_equal(lhs: IntTensor<B>, rhs: IntTensor<B>) -> BoolTensor<B> {
    method int_equal_elem (line 294) | fn int_equal_elem(lhs: IntTensor<B>, rhs: Scalar) -> BoolTensor<B>;
    method int_not_equal_elem (line 306) | fn int_not_equal_elem(lhs: IntTensor<B>, rhs: Scalar) -> BoolTensor<B> {
    method int_greater (line 321) | fn int_greater(lhs: IntTensor<B>, rhs: IntTensor<B>) -> BoolTensor<B>;
    method int_greater_elem (line 333) | fn int_greater_elem(lhs: IntTensor<B>, rhs: Scalar) -> BoolTensor<B>;
    method int_greater_equal (line 345) | fn int_greater_equal(lhs: IntTensor<B>, rhs: IntTensor<B>) -> BoolTens...
    method int_greater_equal_elem (line 357) | fn int_greater_equal_elem(lhs: IntTensor<B>, rhs: Scalar) -> BoolTenso...
    method int_lower (line 369) | fn int_lower(lhs: IntTensor<B>, rhs: IntTensor<B>) -> BoolTensor<B>;
    method int_lower_elem (line 381) | fn int_lower_elem(lhs: IntTensor<B>, rhs: Scalar) -> BoolTensor<B>;
    method int_lower_equal (line 393) | fn int_lower_equal(lhs: IntTensor<B>, rhs: IntTensor<B>) -> BoolTensor...
    method int_lower_equal_elem (line 405) | fn int_lower_equal_elem(lhs: IntTensor<B>, rhs: Scalar) -> BoolTensor<B>;
    method int_add (line 419) | fn int_add(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B>;
    method int_add_scalar (line 431) | fn int_add_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B>;
    method int_powi (line 443) | fn int_powi(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B> {
    method int_powi_scalar (line 467) | fn int_powi_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B> {
    method int_powi_scalar_impl (line 501) | fn int_powi_scalar_impl(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B> {
    method int_clamp_min (line 515) | fn int_clamp_min(tensor: IntTensor<B>, min: Scalar) -> IntTensor<B> {
    method int_clamp_max (line 530) | fn int_clamp_max(tensor: IntTensor<B>, max: Scalar) -> IntTensor<B> {
    method int_clamp (line 546) | fn int_clamp(tensor: IntTensor<B>, min: Scalar, max: Scalar) -> IntTen...
    method int_sub (line 560) | fn int_sub(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B>;
    method int_sub_scalar (line 572) | fn int_sub_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B>;
    method int_mul (line 584) | fn int_mul(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B>;
    method int_mul_scalar (line 596) | fn int_mul_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B>;
    method int_div (line 608) | fn int_div(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B>;
    method int_div_scalar (line 620) | fn int_div_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B>;
    method int_remainder (line 631) | fn int_remainder(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B>;
    method int_remainder_scalar (line 642) | fn int_remainder_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B>;
    method int_matmul (line 654) | fn int_matmul(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B>;
    method int_neg (line 665) | fn int_neg(tensor: IntTensor<B>) -> IntTensor<B> {
    method int_zeros (line 680) | fn int_zeros(shape: Shape, device: &Device<B>, dtype: IntDType) -> Int...
    method int_ones (line 695) | fn int_ones(shape: Shape, device: &Device<B>, dtype: IntDType) -> IntT...
    method int_full (line 711) | fn int_full(
    method int_sum (line 732) | fn int_sum(tensor: IntTensor<B>) -> IntTensor<B>;
    method int_sum_dim (line 744) | fn int_sum_dim(tensor: IntTensor<B>, dim: usize) -> IntTensor<B>;
    method int_prod (line 755) | fn int_prod(tensor: IntTensor<B>) -> IntTensor<B>;
    method int_prod_dim (line 767) | fn int_prod_dim(tensor: IntTensor<B>, dim: usize) -> IntTensor<B>;
    method int_mean (line 778) | fn int_mean(tensor: IntTensor<B>) -> IntTensor<B> {
    method int_mean_dim (line 792) | fn int_mean_dim(tensor: IntTensor<B>, dim: usize) -> IntTensor<B>;
    method int_cumsum (line 805) | fn int_cumsum(tensor: IntTensor<B>, dim: usize) -> IntTensor<B>;
    method int_cumprod (line 818) | fn int_cumprod(tensor: IntTensor<B>, dim: usize) -> IntTensor<B>;
    method int_cummin (line 831) | fn int_cummin(tensor: IntTensor<B>, dim: usize) -> IntTensor<B>;
    method int_cummax (line 844) | fn int_cummax(tensor: IntTensor<B>, dim: usize) -> IntTensor<B>;
    method int_argmax (line 856) | fn int_argmax(tensor: IntTensor<B>, dim: usize) -> IntTensor<B>;
    method int_argmin (line 868) | fn int_argmin(tensor: IntTensor<B>, dim: usize) -> IntTensor<B>;
    method int_max (line 879) | fn int_max(tensor: IntTensor<B>) -> IntTensor<B> {
    method int_max_dim (line 896) | fn int_max_dim(tensor: IntTensor<B>, dim: usize) -> IntTensor<B> {
    method int_max_dim_with_indices (line 911) | fn int_max_dim_with_indices(tensor: IntTensor<B>, dim: usize) -> (IntT...
    method int_max_abs (line 927) | fn int_max_abs(tensor: IntTensor<B>) -> IntTensor<B> {
    method int_max_abs_dim (line 944) | fn int_max_abs_dim(tensor: IntTensor<B>, dim: usize) -> IntTensor<B> {
    method int_min (line 957) | fn int_min(tensor: IntTensor<B>) -> IntTensor<B> {
    method int_min_dim (line 974) | fn int_min_dim(tensor: IntTensor<B>, dim: usize) -> IntTensor<B> {
    method int_min_dim_with_indices (line 989) | fn int_min_dim_with_indices(tensor: IntTensor<B>, dim: usize) -> (IntT...
    method int_abs (line 1005) | fn int_abs(tensor: IntTensor<B>) -> IntTensor<B>;
    method int_transpose (line 1016) | fn int_transpose(tensor: IntTensor<B>) -> IntTensor<B> {
    method int_swap_dims (line 1032) | fn int_swap_dims(tensor: IntTensor<B>, dim1: usize, dim2: usize) -> In...
    method int_permute (line 1043) | fn int_permute(tensor: IntTensor<B>, axes: &[usize]) -> IntTensor<B>;
    method int_flip (line 1053) | fn int_flip(tensor: IntTensor<B>, axes: &[usize]) -> IntTensor<B>;
    method int_random (line 1065) | fn int_random(shape: Shape, distribution: Distribution, device: &Devic...
    method int_arange_step (line 1078) | fn int_arange_step(range: Range<i64>, step: usize, device: &Device<B>)...
    method int_arange (line 1102) | fn int_arange(range: Range<i64>, device: &Device<B>) -> IntTensor<B> {
    method int_any (line 1115) | fn int_any(tensor: IntTensor<B>) -> BoolTensor<B> {
    method int_any_dim (line 1134) | fn int_any_dim(tensor: IntTensor<B>, dim: usize) -> BoolTensor<B> {
    method int_all (line 1151) | fn int_all(tensor: IntTensor<B>) -> BoolTensor<B> {
    method int_all_dim (line 1171) | fn int_all_dim(tensor: IntTensor<B>, dim: usize) -> BoolTensor<B> {
    method int_sign (line 1188) | fn int_sign(tensor: IntTensor<B>) -> IntTensor<B> {
    method int_expand (line 1200) | fn int_expand(tensor: IntTensor<B>, shape: Shape) -> IntTensor<B>;
    method int_sort (line 1215) | fn int_sort(tensor: IntTensor<B>, dim: usize, descending: bool) -> Int...
    method int_sort_with_indices (line 1232) | fn int_sort_with_indices(
    method int_argsort (line 1254) | fn int_argsort(tensor: IntTensor<B>, dim: usize, descending: bool) -> ...
    method bitwise_and (line 1259) | fn bitwise_and(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B>;
    method bitwise_and_scalar (line 1262) | fn bitwise_and_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B>;
    method bitwise_or (line 1265) | fn bitwise_or(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B>;
    method bitwise_or_scalar (line 1268) | fn bitwise_or_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B>;
    method bitwise_xor (line 1271) | fn bitwise_xor(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTensor<B>;
    method bitwise_xor_scalar (line 1274) | fn bitwise_xor_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTensor<B>;
    method bitwise_not (line 1277) | fn bitwise_not(tensor: IntTensor<B>) -> IntTensor<B>;
    method bitwise_left_shift (line 1280) | fn bitwise_left_shift(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTens...
    method bitwise_left_shift_scalar (line 1283) | fn bitwise_left_shift_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTen...
    method bitwise_right_shift (line 1286) | fn bitwise_right_shift(lhs: IntTensor<B>, rhs: IntTensor<B>) -> IntTen...
    method bitwise_right_shift_scalar (line 1289) | fn bitwise_right_shift_scalar(lhs: IntTensor<B>, rhs: Scalar) -> IntTe...
    method int_cast (line 1301) | fn int_cast(tensor: IntTensor<B>, dtype: IntDType) -> IntTensor<B>;
    method int_unfold (line 1320) | fn int_unfold(tensor: IntTensor<B>, dim: usize, size: usize, step: usi...

FILE: crates/burn-backend/src/backend/ops/modules/attention.rs
  function attention_fallback (line 15) | pub fn attention_fallback<B: Backend>(
  function build_causal_mask (line 82) | fn build_causal_mask<B: Backend>(attention_scores: &FloatTensor<B>) -> B...

FILE: crates/burn-backend/src/backend/ops/modules/base.rs
  type Conv2dBackward (line 10) | pub struct Conv2dBackward<B: Backend> {
  type DeformConv2dBackward (line 23) | pub struct DeformConv2dBackward<B: Backend> {
  type Conv3dBackward (line 42) | pub struct Conv3dBackward<B: Backend> {
  type MaxPool1dBackward (line 55) | pub struct MaxPool1dBackward<B: Backend> {
  type MaxPool1dWithIndices (line 62) | pub struct MaxPool1dWithIndices<B: Backend> {
  type MaxPool2dBackward (line 72) | pub struct MaxPool2dBackward<B: Backend> {
  type MaxPool2dWithIndices (line 79) | pub struct MaxPool2dWithIndices<B: Backend> {
  function check_nonzero (line 89) | pub(crate) fn check_nonzero(value: usize, msg: &str) -> usize {
  type ConvOptions (line 96) | pub struct ConvOptions<const N: usize> {
  function new (line 112) | pub fn new(
  type PaddedConvOptions (line 136) | pub struct PaddedConvOptions<const N: usize> {
  function asymmetric (line 150) | pub fn asymmetric(
  function is_asymmetric (line 172) | pub fn is_asymmetric(&self) -> bool {
  function from (line 178) | fn from(options: ConvOptions<N>) -> Self {
  type DeformConvOptions (line 188) | pub struct DeformConvOptions<const N: usize> {
  function new (line 207) | pub fn new(
  type ConvTransposeOptions (line 226) | pub struct ConvTransposeOptions<const N: usize> {
  function new (line 245) | pub fn new(
  type UnfoldOptions (line 264) | pub struct UnfoldOptions {
    method new (line 278) | pub fn new(stride: [usize; 2], padding: [usize; 2], dilation: [usize; ...
  type InterpolateMode (line 289) | pub enum InterpolateMode {
  type InterpolateOptions (line 309) | pub struct InterpolateOptions {
    method new (line 320) | pub fn new(mode: InterpolateMode) -> Self {
    method with_align_corners (line 328) | pub fn with_align_corners(mut self, align_corners: bool) -> Self {
  type GridSamplePaddingMode (line 338) | pub enum GridSamplePaddingMode {
  type GridSampleOptions (line 350) | pub struct GridSampleOptions {
    method from (line 372) | fn from(value: InterpolateMode) -> Self {
    method new (line 381) | pub fn new(mode: InterpolateMode) -> Self {
    method with_padding_mode (line 389) | pub fn with_padding_mode(mut self, padding_mode: GridSamplePaddingMode...
    method with_align_corners (line 395) | pub fn with_align_corners(mut self, align_corners: bool) -> Self {
  method default (line 362) | fn default() -> Self {
  type PadMode (line 412) | pub enum PadMode {
    method from (line 444) | fn from(value: E) -> Self {
  method default (line 438) | fn default() -> Self {
  type InterpolateBackward (line 451) | pub struct InterpolateBackward<B: Backend> {
  type AttentionModuleOptions (line 458) | pub struct AttentionModuleOptions {
  type ModuleOps (line 474) | pub trait ModuleOps<B: Backend> {
    method embedding (line 485) | fn embedding(weights: FloatTensor<B>, indices: IntTensor<B>) -> FloatT...
    method embedding_backward (line 506) | fn embedding_backward(
    method conv1d (line 530) | fn conv1d(
    method conv1d_x_backward (line 539) | fn conv1d_x_backward(
    method conv1d_weight_backward (line 548) | fn conv1d_weight_backward(
    method conv1d_bias_backward (line 557) | fn conv1d_bias_backward(
    method conv2d (line 571) | fn conv2d(
    method conv2d_x_backward (line 578) | fn conv2d_x_backward(
    method conv2d_weight_backward (line 587) | fn conv2d_weight_backward(
    method conv2d_bias_backward (line 596) | fn conv2d_bias_backward(
    method deform_conv2d (line 611) | fn deform_conv2d(
    method deform_conv2d_backward (line 620) | fn deform_conv2d_backward(
    method conv3d (line 637) | fn conv3d(
    method conv3d_x_backward (line 644) | fn conv3d_x_backward(
    method conv3d_weight_backward (line 653) | fn conv3d_weight_backward(
    method conv3d_bias_backward (line 662) | fn conv3d_bias_backward(
    method conv_transpose1d (line 676) | fn conv_transpose1d(
    method conv_transpose1d_x_backward (line 685) | fn conv_transpose1d_x_backward(
    method conv_transpose1d_weight_backward (line 693) | fn conv_transpose1d_weight_backward(
    method conv_transpose1d_bias_backward (line 702) | fn conv_transpose1d_bias_backward(
    method conv_transpose2d (line 717) | fn conv_transpose2d(
    method conv_transpose2d_x_backward (line 724) | fn conv_transpose2d_x_backward(
    method conv_transpose2d_weight_backward (line 732) | fn conv_transpose2d_weight_backward(
    method conv_transpose2d_bias_backward (line 741) | fn conv_transpose2d_bias_backward(
    method conv_transpose3d (line 756) | fn conv_transpose3d(
    method conv_transpose3d_x_backward (line 763) | fn conv_transpose3d_x_backward(
    method conv_transpose3d_weight_backward (line 771) | fn conv_transpose3d_weight_backward(
    method conv_transpose3d_bias_backward (line 780) | fn conv_transpose3d_bias_backward(
    method unfold4d (line 794) | fn unfold4d(
    method avg_pool1d (line 829) | fn avg_pool1d(
    method avg_pool1d_backward (line 847) | fn avg_pool1d_backward(
    method avg_pool2d (line 871) | fn avg_pool2d(
    method avg_pool2d_backward (line 880) | fn avg_pool2d_backward(
    method adaptive_avg_pool2d (line 894) | fn adaptive_avg_pool2d(x: FloatTensor<B>, output_size: [usize; 2]) -> ...
    method adaptive_avg_pool2d_backward (line 896) | fn adaptive_avg_pool2d_backward(x: FloatTensor<B>, grad: FloatTensor<B...
    method adaptive_avg_pool1d (line 902) | fn adaptive_avg_pool1d(x: FloatTensor<B>, output_size: usize) -> Float...
    method adaptive_avg_pool1d_backward (line 906) | fn adaptive_avg_pool1d_backward(x: FloatTensor<B>, grad: FloatTensor<B...
    method max_pool1d (line 914) | fn max_pool1d(
    method max_pool1d_with_indices (line 930) | fn max_pool1d_with_indices(
    method max_pool1d_with_indices_backward (line 949) | fn max_pool1d_with_indices_backward(
    method max_pool2d (line 976) | fn max_pool2d(
    method max_pool2d_with_indices (line 990) | fn max_pool2d_with_indices(
    method max_pool2d_with_indices_backward (line 1000) | fn max_pool2d_with_indices_backward(
    method interpolate (line 1016) | fn interpolate(
    method interpolate_backward (line 1023) | fn interpolate_backward(
    method attention (line 1051) | fn attention(
  function conv_options_stride_zero (line 1067) | fn conv_options_stride_zero() {
  function conv_options_dilation_zero (line 1073) | fn conv_options_dilation_zero() {
  function conv_options_groups_zero (line 1079) | fn conv_options_groups_zero() {
  function conv_transpose_options_stride_zero (line 1085) | fn conv_transpose_options_stride_zero() {
  function conv_transpose_options_dilation_zero (line 1091) | fn conv_transpose_options_dilation_zero() {
  function conv_transpose_options_groups_zero (line 1097) | fn conv_transpose_options_groups_zero() {
  function deform_conv_options_stride_zero (line 1103) | fn deform_conv_options_stride_zero() {
  function deform_conv_options_dilation_zero (line 1109) | fn deform_conv_options_dilation_zero() {
  function deform_conv_options_weights_groups_zero (line 1115) | fn deform_conv_options_weights_groups_zero() {
  function deform_conv_options_offset_groups_zero (line 1121) | fn deform_conv_options_offset_groups_zero() {
  function unfold_options_stride_zero (line 1127) | fn unfold_options_stride_zero() {
  function unfold_options_dilation_zero (line 1133) | fn unfold_options_dilation_zero() {

FILE: crates/burn-backend/src/backend/ops/modules/conv.rs
  function calculate_pool_output_shape (line 12) | pub fn calculate_pool_output_shape<const N: usize>(
  function calculate_conv_output_shape (line 44) | pub fn calculate_conv_output_shape<const N: usize>(
  function calculate_conv_transpose_output_shape (line 80) | pub fn calculate_conv_transpose_output_shape<const N: usize>(
  function calculate_conv_padding (line 124) | pub fn calculate_conv_padding(
  function calculate_conv_output_size (line 142) | pub fn calculate_conv_output_size(
  function calculate_conv_output_sizes (line 153) | pub fn calculate_conv_output_sizes(
  function calculate_conv_transpose_output_size (line 170) | pub fn calculate_conv_transpose_output_size(
  function calculate_pool_output_size (line 192) | pub fn calculate_pool_output_size(
  function conv1d_x_backward (line 211) | pub(crate) fn conv1d_x_backward<B: Backend>(
  function conv1d_weight_backward (line 247) | pub(crate) fn conv1d_weight_backward<B: Backend>(
  function conv1d_bias_backward (line 269) | pub(crate) fn conv1d_bias_backward<B: Backend>(
  function conv2d_x_backward (line 285) | pub(crate) fn conv2d_x_backward<B: Backend>(
  function conv2d_weight_backward (line 329) | pub(crate) fn conv2d_weight_backward<B: Backend>(
  function conv2d_bias_backward (line 351) | pub(crate) fn conv2d_bias_backward<B: Backend>(
  function conv3d_x_backward (line 370) | pub(crate) fn conv3d_x_backward<B: Backend>(
  function conv3d_weight_backward (line 428) | pub(crate) fn conv3d_weight_backward<B: Backend>(
  function conv3d_bias_backward (line 450) | pub(crate) fn conv3d_bias_backward<B: Backend>(
  function conv_transpose1d_x_backward (line 472) | pub(crate) fn conv_transpose1d_x_backward<B: Backend>(
  function conv_transpose1d_weight_backward (line 491) | pub(crate) fn conv_transpose1d_weight_backward<B: Backend>(
  function conv_transpose1d_bias_backward (line 513) | pub(crate) fn conv_transpose1d_bias_backward<B: Backend>(
  function conv_transpose2d_x_backward (line 529) | pub(crate) fn conv_transpose2d_x_backward<B: Backend>(
  function conv_transpose2d_weight_backward (line 548) | pub(crate) fn conv_transpose2d_weight_backward<B: Backend>(
  function conv_transpose2d_bias_backward (line 570) | pub(crate) fn conv_transpose2d_bias_backward<B: Backend>(
  function conv_transpose3d_x_backward (line 589) | pub(crate) fn conv_transpose3d_x_backward<B: Backend>(
  function conv_transpose3d_weight_backward (line 608) | pub(crate) fn conv_transpose3d_weight_backward<B: Backend>(
  function conv_transpose3d_bias_backward (line 630) | pub(crate) fn conv_transpose3d_bias_backward<B: Backend>(
  function conv1d_from_conv2d (line 652) | pub(crate) fn conv1d_from_conv2d<B: Backend>(
  function conv_transpose1d_from_conv_transpose2d (line 683) | pub(crate) fn conv_transpose1d_from_conv_transpose2d<B: Backend>(
  function conv1d_weight_grad_no_groups (line 714) | fn conv1d_weight_grad_no_groups<B: Backend>(
  function conv2d_weight_grad_no_groups (line 741) | fn conv2d_weight_grad_no_groups<B: Backend>(
  function conv3d_weight_grad_no_groups (line 769) | fn conv3d_weight_grad_no_groups<B: Backend>(
  function conv1d_weight_grad_groups (line 798) | fn conv1d_weight_grad_groups<B: Backend>(
  function conv2d_weight_grad_groups (line 849) | fn conv2d_weight_grad_groups<B: Backend>(
  function conv3d_weight_grad_groups (line 913) | fn conv3d_weight_grad_groups<B: Backend>(
  function conv_transpose1d_weight_grad_no_groups (line 994) | fn conv_transpose1d_weight_grad_no_groups<B: Backend>(
  function conv_transpose2d_weight_grad_no_groups (line 1022) | fn conv_transpose2d_weight_grad_no_groups<B: Backend>(
  function conv_transpose3d_weight_grad_no_groups (line 1051) | fn conv_transpose3d_weight_grad_no_groups<B: Backend>(
  function conv_transpose1d_weight_grad_groups (line 1081) | fn conv_transpose1d_weight_grad_groups<B: Backend>(
  function conv_transpose2d_weight_grad_groups (line 1143) | fn conv_transpose2d_weight_grad_groups<B: Backend>(
  function conv_transpose3d_weight_grad_groups (line 1207) | fn conv_transpose3d_weight_grad_groups<B: Backend>(
  function calculate_padding_out (line 1287) | fn calculate_padding_out(
  function test_calculate_output_size_1 (line 1310) | fn test_calculate_output_size_1() {
  function test_calculate_output_size_2 (line 1323) | fn test_calculate_output_size_2() {
  function test_calculate_output_size_3 (line 1336) | fn test_calculate_output_size_3() {
  function test_calculate_same_padding_1 (line 1349) | fn test_calculate_same_padding_1() {
  function test_calculate_same_padding_2 (line 1362) | fn test_calculate_same_padding_2() {
  function test_calculate_output_padding_1 (line 1375) | fn test_calculate_output_padding_1() {
  function test_expect_conv2d_output_shape (line 1390) | fn test_expect_conv2d_output_shape() {

FILE: crates/burn-backend/src/backend/ops/modules/grid_sample.rs
  function float_grid_sample_2d_ref (line 21) | pub fn float_grid_sample_2d_ref<B: Backend>(
  function float_grid_sample_2d_bilinear (line 41) | fn float_grid_sample_2d_bilinear<B: Backend>(
  function reflect_coordinates (line 276) | fn reflect_coordinates<B: Backend>(

FILE: crates/burn-backend/src/backend/ops/modules/pool.rs
  function avg_pool1d_from_2d (line 7) | pub(crate) fn avg_pool1d_from_2d<B: Backend>(
  function avg_pool1d_backward_from_2d (line 32) | pub(crate) fn avg_pool1d_backward_from_2d<B: Backend>(
  function adaptive_avg_pool1d_from_2d (line 60) | pub(crate) fn adaptive_avg_pool1d_from_2d<B: Backend>(
  function adaptive_avg_pool1d_backward_from_2d (line 74) | pub(crate) fn adaptive_avg_pool1d_backward_from_2d<B: Backend>(
  function max_pool1d_from_2d (line 89) | pub(crate) fn max_pool1d_from_2d<B: Backend>(
  function max_pool1d_with_indices_from_2d (line 114) | pub(crate) fn max_pool1d_with_indices_from_2d<B: Backend>(
  function max_pool1d_with_indices_backward_from_2d (line 140) | pub(crate) fn max_pool1d_with_indices_backward_from_2d<B: Backend>(

FILE: crates/burn-backend/src/backend/ops/modules/unfold.rs
  function create_unfolding_weight (line 16) | pub(crate) fn create_unfolding_weight<B: Backend>(
  function unfold4d_using_conv2d (line 55) | pub(crate) fn unfold4d_using_conv2d<B: Backend>(
  function calculate_unfold_windows (line 78) | pub fn calculate_unfold_windows(dim_size: usize, window_size: usize, ste...
  function calculate_unfold_shape (line 105) | pub fn calculate_unfold_shape<S: Into<Shape>>(
  function test_calculate_unfold_windows (line 125) | fn test_calculate_unfold_windows() {
  function test_calculate_unfold_shape (line 140) | fn test_calculate_unfold_shape() {

FILE: crates/burn-backend/src/backend/ops/qtensor.rs
  type QTensorOps (line 122) | pub trait QTensorOps<B: Backend> {
    method q_from_data (line 133) | fn q_from_data(data: TensorData, device: &Device<B>) -> QuantizedTenso...
    method quantize (line 136) | fn quantize(
    method quantize_dynamic (line 143) | fn quantize_dynamic(tensor: FloatTensor<B>, scheme: &QuantScheme) -> Q...
    method dequantize (line 151) | fn dequantize(tensor: QuantizedTensor<B>) -> FloatTensor<B>;
    method q_device (line 162) | fn q_device(tensor: &QuantizedTensor<B>) -> Device<B>;
    method q_to_device (line 174) | fn q_to_device(tensor: QuantizedTensor<B>, device: &Device<B>) -> Quan...
    method q_reshape (line 186) | fn q_reshape(tensor: QuantizedTensor<B>, shape: Shape) -> QuantizedTen...
    method q_into_data (line 197) | fn q_into_data(
    method q_detach (line 202) | fn q_detach(tensor: QuantizedTensor<B>) -> QuantizedTensor<B> {
    method q_set_require_grad (line 208) | fn q_set_require_grad(tensor: QuantizedTensor<B>, _require_grad: bool)...
    method q_is_require_grad (line 214) | fn q_is_require_grad(_tensor: &QuantizedTensor<B>) -> bool {
    method q_expand (line 220) | fn q_expand(tensor: QuantizedTensor<B>, shape: Shape) -> QuantizedTens...
    method q_transpose (line 231) | fn q_transpose(tensor: QuantizedTensor<B>) -> QuantizedTensor<B> {
    method q_swap_dims (line 247) | fn q_swap_dims(tensor: QuantizedTensor<B>, dim1: usize, dim2: usize) -...
    method q_permute (line 258) | fn q_permute(tensor: QuantizedTensor<B>, axes: &[usize]) -> QuantizedT...
    method q_flip (line 268) | fn q_flip(tensor: QuantizedTensor<B>, axes: &[usize]) -> QuantizedTens...
    method q_select (line 281) | fn q_select(
    method q_slice (line 297) | fn q_slice(tensor: QuantizedTensor<B>, slices: &[Slice]) -> QuantizedT...
    method q_gather (line 310) | fn q_gather(
    method q_repeat_dim (line 334) | fn q_repeat_dim(tensor: QuantizedTensor<B>, dim: usize, times: usize) ...
    method q_add (line 352) | fn q_add(lhs: QuantizedTensor<B>, rhs: QuantizedTensor<B>) -> TensorPr...
    method q_add_scalar (line 371) | fn q_add_scalar(lhs: QuantizedTensor<B>, rhs: Scalar) -> TensorPrimiti...
    method q_clamp_min (line 389) | fn q_clamp_min(tensor: QuantizedTensor<B>, min: Scalar) -> TensorPrimi...
    method q_clamp_max (line 407) | fn q_clamp_max(tensor: QuantizedTensor<B>, max: Scalar) -> TensorPrimi...
    method q_clamp (line 426) | fn q_clamp(tensor: QuantizedTensor<B>, min: Scalar, max: Scalar) -> Te...
    method q_sub (line 444) | fn q_sub(lhs: QuantizedTensor<B>, rhs: QuantizedTensor<B>) -> TensorPr...
    method q_sub_scalar (line 463) | fn q_sub_scalar(lhs: QuantizedTensor<B>, rhs: Scalar) -> TensorPrimiti...
    method q_mul (line 472) | fn q_mul(lhs: QuantizedTensor<B>, rhs: QuantizedTensor<B>) -> TensorPr...
    method q_mul_scalar (line 491) | fn q_mul_scalar(lhs: QuantizedTensor<B>, rhs: Scalar) -> TensorPrimiti...
    method q_div (line 509) | fn q_div(lhs: QuantizedTensor<B>, rhs: QuantizedTensor<B>) -> TensorPr...
    method q_div_scalar (line 528) | fn q_div_scalar(lhs: QuantizedTensor<B>, rhs: Scalar) -> TensorPrimiti...
    method q_matmul (line 546) | fn q_matmul(lhs: TensorPrimitive<B>, rhs: TensorPrimitive<B>) -> Tenso...
    method q_neg (line 576) | fn q_neg(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_recip (line 585) | fn q_recip(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_sum (line 602) | fn q_sum(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_sum_dim (line 620) | fn q_sum_dim(tensor: QuantizedTensor<B>, dim: usize) -> TensorPrimitiv...
    method q_prod (line 637) | fn q_prod(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_prod_dim (line 654) | fn q_prod_dim(tensor: QuantizedTensor<B>, dim: usize) -> TensorPrimiti...
    method q_mean (line 671) | fn q_mean(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_mean_dim (line 689) | fn q_mean_dim(tensor: QuantizedTensor<B>, dim: usize) -> TensorPrimiti...
    method q_cumsum (line 708) | fn q_cumsum(tensor: QuantizedTensor<B>, dim: usize) -> TensorPrimitive...
    method q_cumprod (line 727) | fn q_cumprod(tensor: QuantizedTensor<B>, dim: usize) -> TensorPrimitiv...
    method q_cummin (line 746) | fn q_cummin(tensor: QuantizedTensor<B>, dim: usize) -> TensorPrimitive...
    method q_cummax (line 765) | fn q_cummax(tensor: QuantizedTensor<B>, dim: usize) -> TensorPrimitive...
    method q_exp (line 782) | fn q_exp(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_log (line 799) | fn q_log(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_log1p (line 816) | fn q_log1p(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_powf (line 834) | fn q_powf(lhs: QuantizedTensor<B>, rhs: QuantizedTensor<B>) -> TensorP...
    method q_powi (line 853) | fn q_powi(lhs: QuantizedTensor<B>, rhs: IntTensor<B>) -> TensorPrimiti...
    method q_powi_scalar (line 871) | fn q_powi_scalar(lhs: QuantizedTensor<B>, rhs: Scalar) -> TensorPrimit...
    method q_powf_scalar (line 889) | fn q_powf_scalar(tensor: QuantizedTensor<B>, value: Scalar) -> TensorP...
    method q_sqrt (line 906) | fn q_sqrt(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_abs (line 923) | fn q_abs(tensor: QuantizedTensor<B>) -> QuantizedTensor<B> {
    method q_cos (line 940) | fn q_cos(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_sin (line 957) | fn q_sin(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_tan (line 974) | fn q_tan(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_cosh (line 991) | fn q_cosh(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_sinh (line 1008) | fn q_sinh(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_tanh (line 1025) | fn q_tanh(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_erf (line 1042) | fn q_erf(tensor: QuantizedTensor<B>) -> TensorPrimitive<B> {
    method q_cat (line 1060) | fn q_cat(tensors: Vec<QuantizedTensor<B>>, dim: usize) -> QuantizedTen...
    method q_argmax (line 1084) | fn q_argmax(tensor: QuantizedTensor<B>, dim: usize) -> IntTensor<B> {
    method q_argmin (line 1100) | fn q_argmin(tensor: QuantizedTensor<B>, dim: usize) -> IntTensor<B> {
    method q_max (line 1115) | fn q_max(tensor: QuantizedTensor<B>) -> QuantizedTensor<B> {
    method q_max_dim (line 1132) | fn q_max_dim(tensor: QuantizedTensor<B>, dim: usize) -> QuantizedTenso...
    method q_max_dim_with_indices (line 1148) | fn q_max_dim_with_indices(
    method q_min (line 1167) | fn q_min(tensor: QuantizedTensor<B>) -> QuantizedTensor<B> {
    method q_min_dim (line 1184) | fn q_min_dim(tensor: QuantizedTensor<B>, dim: usize) -> QuantizedTenso...
    method q_min_dim_with_indices (line 1200) | fn q_min_dim_with_indices(
    method q_max_abs (line 1219) | fn q_max_abs(tensor: QuantizedTensor<B>) -> QuantizedTensor<B> {
    method q_max_abs_dim (line 1236) | fn q_max_abs_dim(tensor: QuantizedTensor<B>, dim: usize) -> QuantizedT...
    method q_any (line 1251) | fn q_any(tensor: QuantizedTensor<B>) -> BoolTensor<B> {
    method q_any_dim (line 1268) | fn q_any_dim(tensor: QuantizedTensor<B>, dim: usize) -> BoolTensor<B> {
    method q_all (line 1283) | fn q_all(tensor: QuantizedTensor<B>) -> BoolTensor<B> {
    method q_all_dim (line 1300) | fn q_all_dim(tensor: QuantizedTensor<B>, dim: usize) -> BoolTensor<B> {
    method q_sort (line 1318) | fn q_sort(tensor: QuantizedTensor<B>, dim: usize, descending: bool) ->...
    method q_sort_with_indices (line 1341) | fn q_sort_with_indices(
    method q_argsort (line 1368) | fn q_argsort(tensor: QuantizedTensor<B>, dim: usize, descending: bool)...

FILE: crates/burn-backend/src/backend/ops/repeat_dim.rs
  function repeat_with_slice_assign (line 8) | pub(crate) fn repeat_with_slice_assign<B: Backend, K: TensorKind<B> + Ba...

FILE: crates/burn-backend/src/backend/ops/sort.rs
  function sort (line 53) | pub fn sort<B: Backend, K: BasicOps<B>>(
  function sort_data (line 68) | pub fn sort_data<B: Backend, E: ElementOrdered>(
  function sort_with_indices (line 106) | pub fn sort_with_indices<B: Backend, K: BasicOps<B>>(
  function sort_data_with_indices (line 125) | fn sort_data_with_indices<B: Backend, E: ElementOrdered>(
  function argsort (line 200) | pub fn argsort<B: Backend, K: BasicOps<B>>(
  function argsort_data (line 215) | fn argsort_data<B: Backend, E: ElementOrdered>(
  function sort_slice (line 253) | fn sort_slice<B: Backend, E: ElementOrdered>(
  function compute_strides (line 344) | fn compute_strides(dims: &[usize]) -> Vec<usize> {
  function dim_indices (line 357) | fn dim_indices<B: Backend>(dims: &[usize], dim: usize) -> Vec<IntElem<B>> {
  function compare (line 375) | fn compare<E: ElementOrdered>(a: &E, b: &E, descending: bool) -> Ordering {

FILE: crates/burn-backend/src/backend/ops/tensor.rs
  type FloatTensorOps (line 13) | pub trait FloatTensorOps<B: Backend> {
    method float_from_data (line 24) | fn float_from_data(data: TensorData, device: &Device<B>) -> FloatTenso...
    method float_random (line 37) | fn float_random(shape: Shape, distribution: Distribution, device: &Dev...
    method float_zeros (line 51) | fn float_zeros(shape: Shape, device: &Device<B>, dtype: FloatDType) ->...
    method float_ones (line 66) | fn float_ones(shape: Shape, device: &Device<B>, dtype: FloatDType) -> ...
    method float_full (line 82) | fn float_full(
    method float_into_data (line 103) | fn float_into_data(
    method float_device (line 116) | fn float_device(tensor: &FloatTensor<B>) -> Device<B>;
    method float_to_device (line 128) | fn float_to_device(tensor: FloatTensor<B>, device: &Device<B>) -> Floa...
    method float_into_int (line 139) | fn float_into_int(tensor: FloatTensor<B>) -> IntTensor<B>;
    method float_empty (line 152) | fn float_empty(shape: Shape, device: &Device<B>, dtype: FloatDType) ->...
    method float_repeat_dim (line 165) | fn float_repeat_dim(tensor: FloatTensor<B>, dim: usize, times: usize) ...
    method float_add (line 179) | fn float_add(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> FloatTensor<B>;
    method float_add_scalar (line 191) | fn float_add_scalar(lhs: FloatTensor<B>, rhs: Scalar) -> FloatTensor<B>;
    method float_clamp_min (line 203) | fn float_clamp_min(tensor: FloatTensor<B>, min: Scalar) -> FloatTensor...
    method float_clamp_max (line 219) | fn float_clamp_max(tensor: FloatTensor<B>, max: Scalar) -> FloatTensor...
    method float_clamp (line 236) | fn float_clamp(tensor: FloatTensor<B>, min: Scalar, max: Scalar) -> Fl...
    method float_sub (line 251) | fn float_sub(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> FloatTensor<B>;
    method float_sub_scalar (line 263) | fn float_sub_scalar(lhs: FloatTensor<B>, rhs: Scalar) -> FloatTensor<B>;
    method float_mul (line 266) | fn float_mul(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> FloatTensor<B>;
    method float_mul_scalar (line 278) | fn float_mul_scalar(lhs: FloatTensor<B>, rhs: Scalar) -> FloatTensor<B>;
    method float_div (line 290) | fn float_div(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> FloatTensor<B>;
    method float_div_scalar (line 302) | fn float_div_scalar(lhs: FloatTensor<B>, rhs: Scalar) -> FloatTensor<B>;
    method float_remainder (line 314) | fn float_remainder(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> FloatT...
    method float_remainder_scalar (line 325) | fn float_remainder_scalar(lhs: FloatTensor<B>, rhs: Scalar) -> FloatTe...
    method float_matmul (line 337) | fn float_matmul(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> FloatTens...
    method float_cross (line 350) | fn float_cross(lhs: FloatTensor<B>, rhs: FloatTensor<B>, dim: usize) -...
    method float_neg (line 353) | fn float_neg(tensor: FloatTensor<B>) -> FloatTensor<B> {
    method float_recip (line 358) | fn float_recip(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_transpose (line 369) | fn float_transpose(tensor: FloatTensor<B>) -> FloatTensor<B> {
    method float_swap_dims (line 385) | fn float_swap_dims(tensor: FloatTensor<B>, dim1: usize, dim2: usize) -...
    method float_permute (line 396) | fn float_permute(tensor: FloatTensor<B>, axes: &[usize]) -> FloatTenso...
    method float_flip (line 406) | fn float_flip(tensor: FloatTensor<B>, axes: &[usize]) -> FloatTensor<B>;
    method float_reshape (line 418) | fn float_reshape(tensor: FloatTensor<B>, shape: Shape) -> FloatTensor<B>;
    method float_gather (line 431) | fn float_gather(dim: usize, tensor: FloatTensor<B>, indices: IntTensor...
    method float_scatter_add (line 445) | fn float_scatter_add(
    method float_select (line 463) | fn float_select(tensor: FloatTensor<B>, dim: usize, indices: IntTensor...
    method float_select_add (line 478) | fn float_select_add(
    method float_slice (line 500) | fn float_slice(tensor: FloatTensor<B>, slices: &[Slice]) -> FloatTenso...
    method float_slice_assign (line 519) | fn float_slice_assign(
    method float_mask_where (line 536) | fn float_mask_where(
    method float_mask_fill (line 553) | fn float_mask_fill(
    method float_equal (line 569) | fn float_equal(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> BoolTensor...
    method float_not_equal (line 581) | fn float_not_equal(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> BoolTe...
    method float_equal_elem (line 596) | fn float_equal_elem(lhs: FloatTensor<B>, rhs: Scalar) -> BoolTensor<B>;
    method float_not_equal_elem (line 608) | fn float_not_equal_elem(lhs: FloatTensor<B>, rhs: Scalar) -> BoolTenso...
    method float_greater (line 623) | fn float_greater(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> BoolTens...
    method float_greater_elem (line 635) | fn float_greater_elem(lhs: FloatTensor<B>, rhs: Scalar) -> BoolTensor<B>;
    method float_greater_equal (line 647) | fn float_greater_equal(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> Bo...
    method float_greater_equal_elem (line 659) | fn float_greater_equal_elem(lhs: FloatTensor<B>, rhs: Scalar) -> BoolT...
    method float_lower (line 671) | fn float_lower(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> BoolTensor...
    method float_lower_elem (line 683) | fn float_lower_elem(lhs: FloatTensor<B>, rhs: Scalar) -> BoolTensor<B>;
    method float_lower_equal (line 695) | fn float_lower_equal(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> Bool...
    method float_lower_equal_elem (line 707) | fn float_lower_equal_elem(lhs: FloatTensor<B>, rhs: Scalar) -> BoolTen...
    method float_detach (line 710) | fn float_detach(tensor: FloatTensor<B>) -> FloatTensor<B> {
    method float_set_require_grad (line 716) | fn float_set_require_grad(tensor: FloatTensor<B>, _require_grad: bool)...
    method float_is_require_grad (line 722) | fn float_is_require_grad(_tensor: &FloatTensor<B>) -> bool {
    method float_sum (line 736) | fn float_sum(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_sum_dim (line 748) | fn float_sum_dim(tensor: FloatTensor<B>, dim: usize) -> FloatTensor<B>;
    method float_prod (line 759) | fn float_prod(tensor: FloatTensor<B>) -> FloatTensor<B> {
    method float_prod_dim (line 773) | fn float_prod_dim(tensor: FloatTensor<B>, dim: usize) -> FloatTensor<B> {
    method float_mean (line 787) | fn float_mean(tensor: FloatTensor<B>) -> FloatTensor<B> {
    method float_mean_dim (line 802) | fn float_mean_dim(tensor: FloatTensor<B>, dim: usize) -> FloatTensor<B>;
    method float_cumsum (line 815) | fn float_cumsum(tensor: FloatTensor<B>, dim: usize) -> FloatTensor<B>;
    method float_cumprod (line 828) | fn float_cumprod(tensor: FloatTensor<B>, dim: usize) -> FloatTensor<B>;
    method float_cummin (line 841) | fn float_cummin(tensor: FloatTensor<B>, dim: usize) -> FloatTensor<B>;
    method float_cummax (line 854) | fn float_cummax(tensor: FloatTensor<B>, dim: usize) -> FloatTensor<B>;
    method float_cast (line 866) | fn float_cast(tensor: FloatTensor<B>, dtype: FloatDType) -> FloatTenso...
    method float_exp (line 877) | fn float_exp(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_log (line 888) | fn float_log(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_log1p (line 899) | fn float_log1p(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_powf (line 911) | fn float_powf(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> FloatTensor...
    method float_powi (line 923) | fn float_powi(lhs: FloatTensor<B>, rhs: IntTensor<B>) -> FloatTensor<B> {
    method float_powi_scalar (line 947) | fn float_powi_scalar(lhs: FloatTensor<B>, rhs: Scalar) -> FloatTensor<...
    method float_powi_scalar_impl (line 975) | fn float_powi_scalar_impl(lhs: FloatTensor<B>, rhs: Scalar) -> FloatTe...
    method float_powf_scalar (line 997) | fn float_powf_scalar(tensor: FloatTensor<B>, value: Scalar) -> FloatTe...
    method float_powf_scalar_impl (line 1025) | fn float_powf_scalar_impl(tensor: FloatTensor<B>, value: Scalar) -> Fl...
    method float_sqrt (line 1036) | fn float_sqrt(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_abs (line 1047) | fn float_abs(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_cos (line 1058) | fn float_cos(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_sin (line 1069) | fn float_sin(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_tan (line 1080) | fn float_tan(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_cosh (line 1091) | fn float_cosh(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_sinh (line 1102) | fn float_sinh(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_tanh (line 1113) | fn float_tanh(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_acos (line 1124) | fn float_acos(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_acosh (line 1135) | fn float_acosh(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_asin (line 1146) | fn float_asin(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_asinh (line 1157) | fn float_asinh(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_atan (line 1168) | fn float_atan(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_atanh (line 1179) | fn float_atanh(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_atan2 (line 1191) | fn float_atan2(lhs: FloatTensor<B>, rhs: FloatTensor<B>) -> FloatTenso...
    method float_round (line 1205) | fn float_round(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_floor (line 1216) | fn float_floor(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_ceil (line 1227) | fn float_ceil(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_trunc (line 1238) | fn float_trunc(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_erf (line 1249) | fn float_erf(tensor: FloatTensor<B>) -> FloatTensor<B>;
    method float_cat (line 1267) | fn float_cat(tensors: Vec<FloatTensor<B>>, dim: usize) -> FloatTensor<...
    method float_argmax (line 1285) | fn float_argmax(tensor: FloatTensor<B>, dim: usize) -> IntTensor<B>;
    method float_argmin (line 1297) | fn float_argmin(tensor: FloatTensor<B>, dim: usize) -> IntTensor<B>;
    method float_max (line 1308) | fn float_max(tensor: FloatTensor<B>) -> FloatTensor<B> {
    method float_max_dim (line 1325) | fn float_max_dim(tensor: FloatTensor<B>, dim: usize) -> FloatTensor<B> {
    method float_max_dim_with_indices (line 1341) | fn float_max_dim_with_indices(
    method float_min (line 1360) | fn float_min(tensor: FloatTensor<B>) -> FloatTensor<B> {
    method float_min_dim (line 1377) | fn float_min_dim(tensor: FloatTensor<B>, dim: usize) -> FloatTensor<B> {
    method float_min_dim_with_indices (line 1393) | fn float_min_dim_with_indices(
    method float_max_abs (line 1412) | fn float_max_abs(tensor: FloatTensor<B>) -> FloatTensor<B> {
    method float_max_abs_dim (line 1429) | fn float_max_abs_dim(tensor: FloatTensor<B>, dim: usize) -> FloatTenso...
    method float_any (line 1442) | fn float_any(tensor: FloatTensor<B>) -> BoolTensor<B> {
    method float_any_dim (line 1461) | fn float_any_dim(tensor: FloatTensor<B>, dim: usize) -> BoolTensor<B> {
    method float_all (line 1478) | fn float_all(tensor: FloatTensor<B>) -> BoolTensor<B> {
    method float_all_dim (line 1498) | fn float_all_dim(tensor: FloatTensor<B>, dim: usize) -> BoolTensor<B> {
    method float_sign (line 1515) | fn float_sign(tensor: FloatTensor<B>) -> FloatTensor<B> {
    method float_expand (line 1530) | fn float_expand(tensor: FloatTensor<B>, shape: Shape) -> FloatTensor<B>;
    method float_sort (line 1545) | fn float_sort(tensor: FloatTensor<B>, dim: usize, descending: bool) ->...
    method float_sort_with_indices (line 1563) | fn float_sort_with_indices(
    method float_argsort (line 1586) | fn float_argsort(tensor: FloatTensor<B>, dim: usize, descending: bool)...
    method float_grid_sample_2d (line 1603) | fn float_grid_sample_2d(
    method float_unfold (line 1628) | fn float_unfold(tensor: FloatTensor<B>, dim: usize, size: usize, step:...
    method float_is_nan (line 1636) | fn float_is_nan(tensor: FloatTensor<B>) -> BoolTensor<B> {
    method float_is_inf (line 1647) | fn float_is_inf(tensor: FloatTensor<B>) -> BoolTensor<B> {

FILE: crates/burn-backend/src/backend/ops/transaction.rs
  type Order (line 7) | enum Order {
  type TransactionPrimitive (line 16) | pub struct TransactionPrimitive<B: Backend> {
  type TransactionPrimitiveData (line 30) | pub struct TransactionPrimitiveData {
  type TransactionOps (line 43) | pub trait TransactionOps<B: Backend> {
    method tr_execute (line 46) | fn tr_execute(
  function new (line 80) | pub fn new(
  function execute_async (line 96) | pub async fn execute_async(mut self) -> Result<Vec<TensorData>, Executio...
  function register_float (line 117) | pub(crate) fn register_float(&mut self, tensor: TensorPrimitive<B>) {
  function register_int (line 130) | pub(crate) fn register_int(&mut self, tensor: IntTensor<B>) {
  function register_bool (line 135) | pub(crate) fn register_bool(&mut self, tensor: BoolTensor<B>) {

FILE: crates/burn-backend/src/backend/primitive.rs
  type TensorPrimitive (line 7) | pub enum TensorPrimitive<B: Backend> {
  function tensor (line 16) | pub fn tensor(self) -> B::FloatTensorPrimitive {
  type TensorMetadata (line 48) | pub trait TensorMetadata: Clone + Send + Sync + core::fmt::Debug {
    method dtype (line 25) | fn dtype(&self) -> DType {
    method shape (line 32) | fn shape(&self) -> Shape {
    method rank (line 39) | fn rank(&self) -> usize {
    method dtype (line 50) | fn dtype(&self) -> DType;
    method shape (line 52) | fn shape(&self) -> Shape;
    method rank (line 55) | fn rank(&self) -> usize {
  type QTensorPrimitive (line 61) | pub trait QTensorPrimitive {
    method scheme (line 63) | fn scheme(&self) -> &QuantScheme;
    method acc_precision (line 65) | fn acc_precision(&self) -> QuantAcc {
    method propagation (line 69) | fn propagation(&self) -> QuantPropagation {
    method default_scheme (line 74) | fn default_scheme() -> QuantScheme {

FILE: crates/burn-backend/src/data/compare.rs
  type Tolerance (line 28) | pub struct Tolerance<F> {
  method default (line 34) | fn default() -> Self {
  function strict (line 41) | pub fn strict() -> Self {
  function balanced (line 48) | pub fn balanced() -> Self {
  function permissive (line 56) | pub fn permissive() -> Self {
  function rel_abs (line 71) | pub fn rel_abs<FF: ToPrimitive>(relative: FF, absolute: FF) -> Self {
  function relative (line 87) | pub fn relative<FF: ToPrimitive>(tolerance: FF) -> Self {
  function absolute (line 105) | pub fn absolute<FF: ToPrimitive>(tolerance: FF) -> Self {
  function set_relative (line 115) | pub fn set_relative<FF: ToPrimitive>(mut self, tolerance: FF) -> Self {
  function set_half_precision_relative (line 121) | pub fn set_half_precision_relative<FF: ToPrimitive>(mut self, tolerance:...
  function set_single_precision_relative (line 129) | pub fn set_single_precision_relative<FF: ToPrimitive>(mut self, toleranc...
  function set_double_precision_relative (line 137) | pub fn set_double_precision_relative<FF: ToPrimitive>(mut self, toleranc...
  function set_absolute (line 145) | pub fn set_absolute<FF: ToPrimitive>(mut self, tolerance: FF) -> Self {
  function set_half_precision_absolute (line 151) | pub fn set_half_precision_absolute<FF: ToPrimitive>(mut self, tolerance:...
  function set_single_precision_absolute (line 159) | pub fn set_single_precision_absolute<FF: ToPrimitive>(mut self, toleranc...
  function set_double_precision_absolute (line 167) | pub fn set_double_precision_absolute<FF: ToPrimitive>(mut self, toleranc...
  function approx_eq (line 175) | pub fn approx_eq(&self, x: F, y: F) -> bool {
  function check_relative (line 191) | fn check_relative<FF: ToPrimitive>(tolerance: FF) -> F {
  function check_absolute (line 197) | fn check_absolute<FF: ToPrimitive>(tolerance: FF) -> F {
  method assert_eq (line 217) | pub fn assert_eq(&self, other: &Self, strict: bool) {
  method assert_eq_elem (line 261) | fn assert_eq_elem<E: Element>(&self, other: &Self) {
  method assert_approx_eq (line 303) | pub fn assert_approx_eq<F: Float + Element>(&self, other: &Self, toleran...
  method assert_within_range (line 367) | pub fn assert_within_range<E: ElementOrdered>(&self, range: core::ops::R...
  method assert_within_range_inclusive (line 384) | pub fn assert_within_range_inclusive<E: ElementOrdered>(
  function should_assert_appox_eq_limit (line 404) | fn should_assert_appox_eq_limit() {
  function should_assert_approx_eq_above_limit (line 414) | fn should_assert_approx_eq_above_limit() {
  function should_assert_approx_eq_check_shape (line 423) | fn should_assert_approx_eq_check_shape() {

FILE: crates/burn-backend/src/data/tensor.rs
  type TensorData (line 24) | pub struct TensorData {
    method new (line 59) | pub fn new<E: Element, S: Into<Shape>>(value: Vec<E>, shape: S) -> Self {
    method quantized (line 72) | pub fn quantized<E: Element, S: Into<Shape>>(
    method from_bytes (line 91) | pub fn from_bytes<S: Into<Shape>>(bytes: Bytes, shape: S, dtype: DType...
    method from_bytes_vec (line 103) | pub fn from_bytes_vec<S: Into<Shape>>(bytes: Vec<u8>, shape: S, dtype:...
    method check_data_len (line 112) | fn check_data_len<E: Element>(data: &[E], shape: &Shape) {
    method as_slice (line 122) | pub fn as_slice<E: Element>(&self) -> Result<&[E], DataError> {
    method as_mut_slice (line 148) | pub fn as_mut_slice<E: Element>(&mut self) -> Result<&mut [E], DataErr...
    method to_vec (line 172) | pub fn to_vec<E: Element>(&self) -> Result<Vec<E>, DataError> {
    method into_vec (line 177) | pub fn into_vec<E: Element>(self) -> Result<Vec<E>, DataError> {
    method into_vec_unchecked (line 200) | fn into_vec_unchecked<E: Element>(self) -> Result<Vec<E>, DataError> {
    method matches_target_dtype (line 214) | fn matches_target_dtype<E: Element>(&self) -> bool {
    method iter (line 228) | pub fn iter<E: Element>(&self) -> Box<dyn Iterator<Item = E> + '_> {
    method rank (line 343) | pub fn rank(&self) -> usize {
    method num_elements (line 348) | pub fn num_elements(&self) -> usize {
    method numel (line 352) | fn numel(shape: &[usize]) -> usize {
    method random (line 357) | pub fn random<E: Element, R: Rng, S: Into<Shape>>(
    method zeros (line 374) | pub fn zeros<E: Element, S: Into<Shape>>(shape: S) -> TensorData {
    method ones (line 387) | pub fn ones<E: Element, S: Into<Shape>>(shape: S) -> TensorData {
    method full (line 400) | pub fn full<E: Element, S: Into<Shape>>(shape: S, fill_value: E) -> Te...
    method full_dtype (line 412) | pub fn full_dtype<E: Into<Scalar>, S: Into<Shape>>(
    method into_bool_u8 (line 443) | fn into_bool_u8(mut self) -> Self {
    method into_bool_u32 (line 449) | fn into_bool_u32(mut self) -> Self {
    method convert (line 455) | pub fn convert<E: Element>(self) -> Self {
    method convert_dtype (line 460) | pub fn convert_dtype(self, dtype: DType) -> Self {
    method convert_inplace_dtype (line 509) | fn convert_inplace_dtype<Current: Element + AnyBitPattern>(self, dtype...
    method convert_inplace (line 529) | fn convert_inplace<Current: Element + AnyBitPattern, Target: Element +...
    method convert_clone_dtype (line 543) | fn convert_clone_dtype<Current: Element + CheckedBitPattern>(self, dty...
    method convert_clone (line 564) | fn convert_clone<Current: Element + CheckedBitPattern, Target: Element...
    method as_bytes (line 578) | pub fn as_bytes(&self) -> &[u8] {
    method into_bytes (line 583) | pub fn into_bytes(self) -> Bytes {
    method from (line 589) | fn from(elems: [E; A]) -> Self {
    method from (line 595) | fn from(elems: [usize; A]) -> Self {
    method from (line 601) | fn from(elems: &[usize]) -> Self {
    method from (line 612) | fn from(elems: &[E]) -> Self {
    method from (line 623) | fn from(elems: [[E; B]; A]) -> Self {
    method from (line 638) | fn from(elems: [[[E; C]; B]; A]) -> Self {
    method from (line 656) | fn from(elems: [[[[E; D]; C]; B]; A]) -> Self {
    method from (line 676) | fn from(elems: [[[[[Elem; E]; D]; C]; B]; A]) -> Self {
    method fmt (line 695) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  function serialize (line 42) | pub fn serialize<S: serde::Serializer>(
  function deserialize (line 49) | pub fn deserialize<'de, D: serde::Deserializer<'de>>(
  type DataError (line 745) | pub enum DataError {
  function should_have_rank (line 765) | fn should_have_rank() {
  function into_vec_should_yield_same_value_as_iter (line 777) | fn into_vec_should_yield_same_value_as_iter() {
  function into_vec_should_assert_wrong_dtype (line 793) | fn into_vec_should_assert_wrong_dtype() {
  function should_have_right_num_elements (line 805) | fn should_have_right_num_elements() {
  function should_have_right_shape (line 819) | fn should_have_right_shape() {
  function should_convert_bytes_correctly (line 831) | fn should_convert_bytes_correctly() {
  function should_convert_bytes_correctly_inplace (line 843) | fn should_convert_bytes_correctly_inplace() {
  function should_serialize_deserialize_tensor_data (line 896) | fn should_serialize_deserialize_tensor_data() {
  function should_deserialize_tensor_data_with_shape_inner (line 911) | fn should_deserialize_tensor_data_with_shape_inner() {
  function should_serialize_shape_as_flat_array (line 928) | fn should_serialize_shape_as_flat_array() {

FILE: crates/burn-backend/src/distribution.rs
  type Distribution (line 9) | pub enum Distribution {
    method sampler (line 89) | pub fn sampler<R, E>(self, rng: &'_ mut R) -> DistributionSampler<'_, ...
  type DistributionSampler (line 26) | pub struct DistributionSampler<'a, E, R>
  type DistributionSamplerKind (line 37) | pub enum DistributionSamplerKind<E>
  function sample (line 63) | pub fn sample(&mut self) -> E {
  function test_distribution_default (line 119) | fn test_distribution_default() {

FILE: crates/burn-backend/src/element/base.rs
  type Element (line 16) | pub trait Element:
    method dtype (line 34) | fn dtype() -> DType;
  type ElementOrdered (line 44) | pub trait ElementOrdered: Element + ElementComparison {}
  type ElementConversion (line 47) | pub trait ElementConversion {
    method from_elem (line 57) | fn from_elem<E: ToElement>(elem: E) -> Self;
    method elem (line 60) | fn elem<E: Element>(self) -> E;
  type ElementRandom (line 64) | pub trait ElementRandom {
    method random (line 75) | fn random<R: Rng>(distribution: Distribution, rng: &mut R) -> Self;
  type ElementEq (line 79) | pub trait ElementEq {
    method eq (line 81) | fn eq(&self, other: &Self) -> bool;
  type ElementComparison (line 85) | pub trait ElementComparison {
    method cmp (line 87) | fn cmp(&self, other: &Self) -> Ordering;
  type ElementLimits (line 91) | pub trait ElementLimits {
    constant MIN (line 93) | const MIN: Self;
    constant MAX (line 95) | const MAX: Self;

FILE: crates/burn-backend/src/element/cast.rs
  type ToElement (line 18) | pub trait ToElement {
    method to_isize (line 21) | fn to_isize(&self) -> isize {
    method to_i8 (line 27) | fn to_i8(&self) -> i8 {
    method to_i16 (line 33) | fn to_i16(&self) -> i16 {
    method to_i32 (line 39) | fn to_i32(&self) -> i32 {
    method to_i64 (line 44) | fn to_i64(&self) -> i64;
    method to_i128 (line 51) | fn to_i128(&self) -> i128 {
    method to_usize (line 57) | fn to_usize(&self) -> usize {
    method to_u8 (line 63) | fn to_u8(&self) -> u8 {
    method to_u16 (line 69) | fn to_u16(&self) -> u16 {
    method to_u32 (line 75) | fn to_u32(&self) -> u32 {
    method to_u64 (line 80) | fn to_u64(&self) -> u64;
    method to_u128 (line 87) | fn to_u128(&self) -> u128 {
    method to_f16 (line 94) | fn to_f16(&self) -> f16 {
    method to_bf16 (line 101) | fn to_bf16(&self) -> bf16 {
    method to_f32 (line 108) | fn to_f32(&self) -> f32 {
    method to_f64 (line 119) | fn to_f64(&self) -> f64 {
    method to_bool (line 131) | fn to_bool(&self) -> bool {
    method to_i64 (line 420) | fn to_i64(&self) -> i64 {
    method to_u64 (line 424) | fn to_u64(&self) -> u64 {
    method to_i8 (line 428) | fn to_i8(&self) -> i8 {
    method to_u8 (line 432) | fn to_u8(&self) -> u8 {
    method to_i16 (line 436) | fn to_i16(&self) -> i16 {
    method to_u16 (line 440) | fn to_u16(&self) -> u16 {
    method to_i32 (line 444) | fn to_i32(&self) -> i32 {
    method to_u32 (line 448) | fn to_u32(&self) -> u32 {
    method to_f16 (line 452) | fn to_f16(&self) -> f16 {
    method to_f32 (line 456) | fn to_f32(&self) -> f32 {
    method to_f64 (line 460) | fn to_f64(&self) -> f64 {
    method to_bool (line 464) | fn to_bool(&self) -> bool {
    method to_i64 (line 471) | fn to_i64(&self) -> i64 {
    method to_u64 (line 475) | fn to_u64(&self) -> u64 {
    method to_i8 (line 479) | fn to_i8(&self) -> i8 {
    method to_u8 (line 483) | fn to_u8(&self) -> u8 {
    method to_i16 (line 487) | fn to_i16(&self) -> i16 {
    method to_u16 (line 491) | fn to_u16(&self) -> u16 {
    method to_i32 (line 495) | fn to_i32(&self) -> i32 {
    method to_u32 (line 499) | fn to_u32(&self) -> u32 {
    method to_bf16 (line 503) | fn to_bf16(&self) -> bf16 {
    method to_f32 (line 507) | fn to_f32(&self) -> f32 {
    method to_f64 (line 511) | fn to_f64(&self) -> f64 {
    method to_bool (line 515) | fn to_bool(&self) -> bool {
    method to_i64 (line 523) | fn to_i64(&self) -> i64 {
    method to_u64 (line 527) | fn to_u64(&self) -> u64 {
    method to_i8 (line 531) | fn to_i8(&self) -> i8 {
    method to_u8 (line 535) | fn to_u8(&self) -> u8 {
    method to_i16 (line 539) | fn to_i16(&self) -> i16 {
    method to_u16 (line 543) | fn to_u16(&self) -> u16 {
    method to_i32 (line 547) | fn to_i32(&self) -> i32 {
    method to_u32 (line 551) | fn to_u32(&self) -> u32 {
    method to_f32 (line 555) | fn to_f32(&self) -> f32 {
    method to_f64 (line 559) | fn to_f64(&self) -> f64 {
    method to_bool (line 563) | fn to_bool(&self) -> bool {
    method to_i64 (line 570) | fn to_i64(&self) -> i64 {
    method to_u64 (line 574) | fn to_u64(&self) -> u64 {
    method to_i8 (line 578) | fn to_i8(&self) -> i8 {
    method to_u8 (line 582) | fn to_u8(&self) -> u8 {
    method to_i16 (line 586) | fn to_i16(&self) -> i16 {
    method to_u16 (line 590) | fn to_u16(&self) -> u16 {
    method to_i32 (line 594) | fn to_i32(&self) -> i32 {
    method to_u32 (line 598) | fn to_u32(&self) -> u32 {
    method to_f32 (line 602) | fn to_f32(&self) -> f32 {
    method to_f64 (line 606) | fn to_f64(&self) -> f64 {
    method to_bool (line 610) | fn to_bool(&self) -> bool {
  function to_element_float (line 620) | fn to_element_float() {
  function to_element_signed_to_u8_underflow (line 633) | fn to_element_signed_to_u8_underflow() {
  function to_element_signed_to_u16_underflow (line 639) | fn to_element_signed_to_u16_underflow() {
  function to_element_signed_to_u32_underflow (line 645) | fn to_element_signed_to_u32_underflow() {
  function to_element_signed_to_u64_underflow (line 651) | fn to_element_signed_to_u64_underflow() {
  function to_element_signed_to_u128_underflow (line 657) | fn to_element_signed_to_u128_underflow() {
  function to_element_signed_to_usize_underflow (line 663) | fn to_element_signed_to_usize_underflow() {
  function to_element_unsigned_to_u8_overflow (line 669) | fn to_element_unsigned_to_u8_overflow() {
  function to_element_unsigned_to_u16_overflow (line 675) | fn to_element_unsigned_to_u16_overflow() {
  function to_element_unsigned_to_u32_overflow (line 681) | fn to_element_unsigned_to_u32_overflow() {
  function to_element_unsigned_to_u64_overflow (line 687) | fn to_element_unsigned_to_u64_overflow() {
  function to_element_int_to_float (line 692) | fn to_element_int_to_float() {
  function to_element_float_to_int (line 700) | fn to_element_float_to_int() {

FILE: crates/burn-backend/src/element/scalar.rs
  type Scalar (line 13) | pub enum Scalar {
    method new (line 25) | pub fn new<E: ElementConversion>(value: E, dtype: &DType) -> Self {
    method elem (line 40) | pub fn elem<E: Element>(self) -> E {
    method try_as_integer (line 50) | pub fn try_as_integer(&self) -> Option<Self> {
  method to_i64 (line 79) | fn to_i64(&self) -> Option<i64> {
  method to_u64 (line 88) | fn to_u64(&self) -> Option<u64> {
  method to_f64 (line 97) | fn to_f64(&self) -> Option<f64> {

FILE: crates/burn-backend/src/tensor/alias.rs
  type Device (line 7) | pub type Device<B> = <B as Backend>::Device;
  type FloatElem (line 10) | pub type FloatElem<B> = <B as Backend>::FloatElem;
  type IntElem (line 12) | pub type IntElem<B> = <B as Backend>::IntElem;
  type BoolElem (line 14) | pub type BoolElem<B> = <B as Backend>::BoolElem;
  type FloatTensor (line 17) | pub type FloatTensor<B> = <B as Backend>::FloatTensorPrimitive;
  type IntTensor (line 19) | pub type IntTensor<B> = <B as Backend>::IntTensorPrimitive;
  type BoolTensor (line 21) | pub type BoolTensor<B> = <B as Backend>::BoolTensorPrimitive;
  type QuantizedTensor (line 23) | pub type QuantizedTensor<B> = <B as Backend>::QuantizedTensorPrimitive;

FILE: crates/burn-backend/src/tensor/container.rs
  type TensorContainer (line 16) | pub struct TensorContainer<ID> {
  method default (line 24) | fn default() -> Self {
  function new (line 34) | pub fn new() -> Self {
  function get (line 41) | pub fn get<B>(&self, id: &ID) -> Option<TensorPrimitive<B>>
  function register (line 60) | pub fn register<B>(&mut self, id: ID, value: TensorPrimitive<B>)
  function remove (line 68) | pub fn remove<B>(&mut self, id: &ID) -> Option<TensorPrimitive<B>>
  function len (line 79) | pub fn len(&self) -> usize {
  function is_empty (line 84) | pub fn is_empty(&self) -> bool {
  function ids (line 89) | pub fn ids(&self) -> Vec<&ID> {

FILE: crates/burn-backend/src/tensor/kind.rs
  type Float (line 5) | pub struct Float;
    type Primitive (line 26) | type Primitive = TensorPrimitive<B>;
    method name (line 27) | fn name() -> &'static str {
  type Int (line 9) | pub struct Int;
    type Primitive (line 33) | type Primitive = B::IntTensorPrimitive;
    method name (line 34) | fn name() -> &'static str {
  type Bool (line 13) | pub struct Bool;
    type Primitive (line 40) | type Primitive = B::BoolTensorPrimitive;
    method name (line 41) | fn name() -> &'static str {
  type TensorKind (line 17) | pub trait TensorKind<B: Backend>: Clone + core::fmt::Debug {
    method name (line 22) | fn name() -> &'static str;

FILE: crates/burn-backend/src/tensor/ops/autodiff.rs
  type BasicAutodiffOps (line 14) | pub trait BasicAutodiffOps<B: AutodiffBackend>: BasicOps<B> + BasicOps<B...
    method inner (line 30) | fn inner(
    method from_inner (line 46) | fn from_inner(

FILE: crates/burn-backend/src/tensor/ops/base.rs
  type BasicOps (line 19) | pub trait BasicOps<B: Backend>: TensorKind<B> {
    method empty (line 45) | fn empty(shape: Shape, device: &B::Device, dtype: DType) -> Self::Prim...
    method zeros (line 69) | fn zeros(shape: Shape, device: &B::Device, dtype: DType) -> Self::Prim...
    method ones (line 93) | fn ones(shape: Shape, device: &B::Device, dtype: DType) -> Self::Primi...
    method full (line 118) | fn full(shape: Shape, fill_value: Scalar, device: &B::Device, dtype: D...
    method reshape (line 141) | fn reshape(tensor: Self::Primitive, shape: Shape) -> Self::Primitive;
    method transpose (line 152) | fn transpose(tensor: Self::Primitive) -> Self::Primitive;
    method swap_dims (line 165) | fn swap_dims(tensor: Self::Primitive, dim1: usize, dim2: usize) -> Sel...
    method permute (line 177) | fn permute(tensor: Self::Primitive, axes: &[usize]) -> Self::Primitive;
    method flip (line 189) | fn flip(tensor: Self::Primitive, axes: &[usize]) -> Self::Primitive;
    method slice (line 212) | fn slice(tensor: Self::Primitive, slices: &[Slice]) -> Self::Primitive;
    method slice_assign (line 236) | fn slice_assign(
    method select (line 264) | fn select(tensor: Self::Primitive, dim: usize, indices: IntTensor<B>) ...
    method select_assign (line 294) | fn select_assign(
    method mask_where (line 326) | fn mask_where(
    method mask_fill (line 357) | fn mask_fill(
    method gather (line 386) | fn gather(dim: usize, tensor: Self::Primitive, indices: IntTensor<B>) ...
    method scatter (line 415) | fn scatter(
    method device (line 443) | fn device(tensor: &Self::Primitive) -> B::Device;
    method to_device (line 467) | fn to_device(tensor: Self::Primitive, device: &B::Device) -> Self::Pri...
    method into_data_async (line 490) | fn into_data_async(
    method register_transaction (line 501) | fn register_transaction(tr: &mut TransactionPrimitive<B>, tensor: Self...
    method from_data (line 524) | fn from_data(data: TensorData, device: &B::Device) -> Self::Primitive;
    method from_data_dtype (line 537) | fn from_data_dtype(data: TensorData, device: &B::Device, dtype: DType)...
    method repeat_dim (line 561) | fn repeat_dim(tensor: Self::Primitive, dim: usize, times: usize) -> Se...
    method cat (line 584) | fn cat(vectors: Vec<Self::Primitive>, dim: usize) -> Self::Primitive;
    method equal (line 607) | fn equal(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTensorP...
    method equal_elem (line 631) | fn equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorPrimi...
    method not_equal (line 654) | fn not_equal(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTen...
    method not_equal_elem (line 678) | fn not_equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorP...
    method elem_type_name (line 681) | fn elem_type_name() -> &'static str {
    method dtype (line 686) | fn dtype(tensor: &Self::Primitive) -> DType {
    method any (line 708) | fn any(tensor: Self::Primitive) -> B::BoolTensorPrimitive;
    method any_dim (line 730) | fn any_dim(tensor: Self::Primitive, dim: usize) -> B::BoolTensorPrimit...
    method all (line 750) | fn all(tensor: Self::Primitive) -> B::BoolTensorPrimitive;
    method all_dim (line 771) | fn all_dim(tensor: Self::Primitive, dim: usize) -> B::BoolTensorPrimit...
    method expand (line 783) | fn expand(tensor: Self::Primitive, shape: Shape) -> Self::Primitive;
    method unfold (line 806) | fn unfold(tensor: Self::Primitive, dim: usize, size: usize, step: usiz...

FILE: crates/burn-backend/src/tensor/ops/bool.rs
  type Elem (line 12) | type Elem = B::BoolElem;
  method empty (line 14) | fn empty(shape: Shape, device: &Device<B>, dtype: DType) -> Self::Primit...
  method zeros (line 21) | fn zeros(shape: Shape, device: &Device<B>, dtype: DType) -> Self::Primit...
  method ones (line 27) | fn ones(shape: Shape, device: &Device<B>, dtype: DType) -> Self::Primiti...
  method full (line 34) | fn full(shape: Shape, fill_value: Scalar, device: &Device<B>, dtype: DTy...
  method register_transaction (line 45) | fn register_transaction(tr: &mut TransactionPrimitive<B>, tensor: Self::...
  method reshape (line 49) | fn reshape(tensor: Self::Primitive, shape: Shape) -> Self::Primitive {
  method transpose (line 53) | fn transpose(tensor: Self::Primitive) -> Self::Primitive {
  method swap_dims (line 57) | fn swap_dims(tensor: Self::Primitive, dim1: usize, dim2: usize) -> Self:...
  method slice (line 61) | fn slice(tensor: Self::Primitive, slices: &[Slice]) -> Self::Primitive {
  method slice_assign (line 65) | fn slice_assign(
  method select (line 73) | fn select(tensor: Self::Primitive, dim: usize, indices: IntTensor<B>) ->...
  method select_assign (line 77) | fn select_assign(
  method mask_where (line 89) | fn mask_where(
  method mask_fill (line 97) | fn mask_fill(
  method gather (line 105) | fn gather(
  method scatter (line 113) | fn scatter(
  method device (line 125) | fn device(tensor: &Self::Primitive) -> Device<B> {
  method to_device (line 129) | fn to_device(tensor: Self::Primitive, device: &Device<B>) -> Self::Primi...
  method into_data_async (line 133) | async fn into_data_async(tensor: Self::Primitive) -> Result<TensorData, ...
  method from_data (line 137) | fn from_data(data: TensorData, device: &Device<B>) -> Self::Primitive {
  method from_data_dtype (line 141) | fn from_data_dtype(data: TensorData, device: &Device<B>, _dtype: DType) ...
  method repeat_dim (line 147) | fn repeat_dim(tensor: Self::Primitive, dim: usize, times: usize) -> Self...
  method equal (line 151) | fn equal(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTensorPri...
  method not_equal (line 155) | fn not_equal(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTenso...
  method equal_elem (line 159) | fn equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorPrimiti...
  method not_equal_elem (line 163) | fn not_equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorPri...
  method cat (line 167) | fn cat(vectors: Vec<Self::Primitive>, dim: usize) -> Self::Primitive {
  method any (line 171) | fn any(tensor: Self::Primitive) -> B::BoolTensorPrimitive {
  method any_dim (line 175) | fn any_dim(tensor: Self::Primitive, dim: usize) -> B::BoolTensorPrimitive {
  method all (line 179) | fn all(tensor: Self::Primitive) -> B::BoolTensorPrimitive {
  method all_dim (line 183) | fn all_dim(tensor: Self::Primitive, dim: usize) -> B::BoolTensorPrimitive {
  method permute (line 187) | fn permute(tensor: Self::Primitive, axes: &[usize]) -> Self::Primitive {
  method expand (line 191) | fn expand(tensor: Self::Primitive, shape: Shape) -> Self::Primitive {
  method flip (line 195) | fn flip(tensor: Self::Primitive, axes: &[usize]) -> Self::Primitive {
  method unfold (line 199) | fn unfold(tensor: Self::Primitive, dim: usize, size: usize, step: usize)...
  type InnerKind (line 205) | type InnerKind = Bool;
  method inner (line 207) | fn inner(
  method from_inner (line 213) | fn from_inner(

FILE: crates/burn-backend/src/tensor/ops/float.rs
  type Elem (line 31) | type Elem = B::FloatElem;
  method empty (line 33) | fn empty(shape: Shape, device: &Device<B>, dtype: DType) -> Self::Primit...
  method zeros (line 37) | fn zeros(shape: Shape, device: &Device<B>, dtype: DType) -> Self::Primit...
  method ones (line 40) | fn ones(shape: Shape, device: &Device<B>, dtype: DType) -> Self::Primiti...
  method full (line 44) | fn full(shape: Shape, fill_value: Scalar, device: &Device<B>, dtype: DTy...
  method register_transaction (line 48) | fn register_transaction(tr: &mut TransactionPrimitive<B>, tensor: Self::...
  method reshape (line 52) | fn reshape(tensor: Self::Primitive, shape: Shape) -> Self::Primitive {
  method transpose (line 61) | fn transpose(tensor: Self::Primitive) -> Self::Primitive {
  method swap_dims (line 68) | fn swap_dims(tensor: Self::Primitive, dim1: usize, dim2: usize) -> Self:...
  method slice (line 79) | fn slice(tensor: Self::Primitive, slices: &[Slice]) -> Self::Primitive {
  method slice_assign (line 88) | fn slice_assign(
  method select (line 100) | fn select(tensor: Self::Primitive, dim: usize, indices: IntTensor<B>) ->...
  method select_assign (line 111) | fn select_assign(
  method mask_where (line 129) | fn mask_where(
  method mask_fill (line 137) | fn mask_fill(
  method gather (line 145) | fn gather(dim: usize, tensor: Self::Primitive, indices: IntTensor<B>) ->...
  method scatter (line 156) | fn scatter(
  method device (line 173) | fn device(tensor: &Self::Primitive) -> Device<B> {
  method to_device (line 180) | fn to_device(tensor: Self::Primitive, device: &Device<B>) -> Self::Primi...
  method into_data_async (line 191) | async fn into_data_async(tensor: Self::Primitive) -> Result<TensorData, ...
  method from_data (line 198) | fn from_data(data: TensorData, device: &Device<B>) -> Self::Primitive {
  method from_data_dtype (line 205) | fn from_data_dtype(data: TensorData, device: &Device<B>, dtype: DType) -...
  method repeat_dim (line 217) | fn repeat_dim(tensor: Self::Primitive, dim: usize, times: usize) -> Self...
  method cat (line 228) | fn cat(vectors: Vec<Self::Primitive>, dim: usize) -> Self::Primitive {
  method equal (line 250) | fn equal(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTensorPri...
  method not_equal (line 254) | fn not_equal(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTenso...
  method equal_elem (line 258) | fn equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorPrimiti...
  method not_equal_elem (line 262) | fn not_equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorPri...
  method any (line 266) | fn any(tensor: Self::Primitive) -> B::BoolTensorPrimitive {
  method any_dim (line 270) | fn any_dim(tensor: Self::Primitive, dim: usize) -> B::BoolTensorPrimitive {
  method all (line 274) | fn all(tensor: Self::Primitive) -> B::BoolTensorPrimitive {
  method all_dim (line 278) | fn all_dim(tensor: Self::Primitive, dim: usize) -> B::BoolTensorPrimitive {
  method permute (line 282) | fn permute(tensor: Self::Primitive, axes: &[usize]) -> Self::Primitive {
  method expand (line 291) | fn expand(tensor: Self::Primitive, shape: Shape) -> Self::Primitive {
  method flip (line 295) | fn flip(tensor: Self::Primitive, axes: &[usize]) -> Self::Primitive {
  method unfold (line 302) | fn unfold(tensor: Self::Primitive, dim: usize, size: usize, step: usize)...
  method add (line 308) | fn add(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive {
  method add_scalar (line 312) | fn add_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive {
  method sub (line 319) | fn sub(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive {
  method sub_scalar (line 323) | fn sub_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive {
  method div (line 330) | fn div(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive {
  method div_scalar (line 334) | fn div_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive {
  method remainder (line 340) | fn remainder(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primit...
  method remainder_scalar (line 344) | fn remainder_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive {
  method mul (line 348) | fn mul(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive {
  method mul_scalar (line 352) | fn mul_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive {
  method neg (line 358) | fn neg(tensor: Self::Primitive) -> Self::Primitive {
  method sum (line 365) | fn sum(tensor: Self::Primitive) -> Self::Primitive {
  method sum_dim (line 372) | fn sum_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method prod (line 379) | fn prod(tensor: Self::Primitive) -> Self::Primitive {
  method prod_dim (line 386) | fn prod_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method mean (line 395) | fn mean(tensor: Self::Primitive) -> Self::Primitive {
  method mean_dim (line 402) | fn mean_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method cumsum (line 411) | fn cumsum(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method cumprod (line 418) | fn cumprod(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method abs (line 425) | fn abs(tensor: Self::Primitive) -> Self::Primitive {
  method powi (line 432) | fn powi(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive {
  method powi_scalar (line 436) | fn powi_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive {
  method random (line 443) | fn random(shape: Shape, distribution: Distribution, device: &Device<B>) ...
  method sign (line 447) | fn sign(tensor: Self::Primitive) -> Self::Primitive {
  method matmul (line 458) | fn matmul(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive {
  method sort (line 468) | fn sort(tensor: Self::Primitive, dim: usize, descending: bool) -> Self::...
  method sort_with_indices (line 479) | fn sort_with_indices(
  method argsort (line 496) | fn argsort(tensor: Self::Primitive, dim: usize, descending: bool) -> Int...
  method cummin (line 503) | fn cummin(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method cummax (line 510) | fn cummax(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method greater (line 517) | fn greater(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTensorP...
  method greater_elem (line 521) | fn greater_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorPrimi...
  method greater_equal (line 525) | fn greater_equal(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolT...
  method greater_equal_elem (line 529) | fn greater_equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTenso...
  method lower (line 533) | fn lower(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTensorPri...
  method lower_elem (line 537) | fn lower_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorPrimiti...
  method lower_equal (line 541) | fn lower_equal(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTen...
  method lower_equal_elem (line 545) | fn lower_equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorP...
  method argmax (line 549) | fn argmax(tensor: Self::Primitive, dim: usize) -> IntTensor<B> {
  method argmin (line 556) | fn argmin(tensor: Self::Primitive, dim: usize) -> IntTensor<B> {
  method max (line 563) | fn max(tensor: Self::Primitive) -> Self::Primitive {
  method max_dim (line 570) | fn max_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method max_dim_with_indices (line 577) | fn max_dim_with_indices(
  method min (line 593) | fn min(tensor: Self::Primitive) -> Self::Primitive {
  method min_dim (line 600) | fn min_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method min_dim_with_indices (line 607) | fn min_dim_with_indices(
  method clamp (line 623) | fn clamp(tensor: Self::Primitive, min: Scalar, max: Scalar) -> Self::Pri...
  method clamp_min (line 632) | fn clamp_min(tensor: Self::Primitive, min: Scalar) -> Self::Primitive {
  method clamp_max (line 641) | fn clamp_max(tensor: Self::Primitive, max: Scalar) -> Self::Primitive {
  method max_abs (line 650) | fn max_abs(tensor: Self::Primitive) -> Self::Primitive {
  method max_abs_dim (line 657) | fn max_abs_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  type InnerKind (line 670) | type InnerKind = Float;
  method inner (line 672) | fn inner(
  method from_inner (line 681) | fn from_inner(

FILE: crates/burn-backend/src/tensor/ops/int.rs
  type Elem (line 14) | type Elem = B::IntElem;
  method empty (line 16) | fn empty(shape: Shape, device: &Device<B>, dtype: DType) -> Self::Primit...
  method zeros (line 20) | fn zeros(shape: Shape, device: &Device<B>, dtype: DType) -> Self::Primit...
  method ones (line 23) | fn ones(shape: Shape, device: &Device<B>, dtype: DType) -> Self::Primiti...
  method full (line 27) | fn full(shape: Shape, fill_value: Scalar, device: &Device<B>, dtype: DTy...
  method register_transaction (line 31) | fn register_transaction(tr: &mut TransactionPrimitive<B>, tensor: Self::...
  method reshape (line 35) | fn reshape(tensor: Self::Primitive, shape: Shape) -> Self::Primitive {
  method transpose (line 39) | fn transpose(tensor: Self::Primitive) -> Self::Primitive {
  method swap_dims (line 43) | fn swap_dims(tensor: Self::Primitive, dim1: usize, dim2: usize) -> Self:...
  method slice (line 47) | fn slice(tensor: Self::Primitive, slices: &[Slice]) -> Self::Primitive {
  method slice_assign (line 51) | fn slice_assign(
  method select (line 59) | fn select(tensor: Self::Primitive, dim: usize, indices: IntTensor<B>) ->...
  method select_assign (line 63) | fn select_assign(
  method mask_where (line 75) | fn mask_where(
  method mask_fill (line 83) | fn mask_fill(
  method gather (line 91) | fn gather(
  method scatter (line 99) | fn scatter(
  method device (line 111) | fn device(tensor: &Self::Primitive) -> Device<B> {
  method to_device (line 115) | fn to_device(tensor: Self::Primitive, device: &Device<B>) -> Self::Primi...
  method into_data_async (line 119) | async fn into_data_async(tensor: Self::Primitive) -> Result<TensorData, ...
  method from_data (line 123) | fn from_data(data: TensorData, device: &Device<B>) -> Self::Primitive {
  method from_data_dtype (line 127) | fn from_data_dtype(data: TensorData, device: &Device<B>, dtype: DType) -...
  method repeat_dim (line 135) | fn repeat_dim(tensor: Self::Primitive, dim: usize, times: usize) -> Self...
  method equal (line 139) | fn equal(lhs: Self::Primitive, rhs: Self::Primitive) -> BoolTensor<B> {
  method not_equal (line 143) | fn not_equal(lhs: Self::Primitive, rhs: Self::Primitive) -> BoolTensor<B> {
  method equal_elem (line 147) | fn equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorPrimiti...
  method not_equal_elem (line 151) | fn not_equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorPri...
  method cat (line 155) | fn cat(vectors: Vec<Self::Primitive>, dim: usize) -> Self::Primitive {
  method any (line 159) | fn any(tensor: Self::Primitive) -> BoolTensor<B> {
  method any_dim (line 163) | fn any_dim(tensor: Self::Primitive, dim: usize) -> BoolTensor<B> {
  method all (line 167) | fn all(tensor: Self::Primitive) -> BoolTensor<B> {
  method all_dim (line 171) | fn all_dim(tensor: Self::Primitive, dim: usize) -> BoolTensor<B> {
  method permute (line 175) | fn permute(tensor: Self::Primitive, axes: &[usize]) -> Self::Primitive {
  method expand (line 179) | fn expand(tensor: Self::Primitive, shape: Shape) -> Self::Primitive {
  method flip (line 183) | fn flip(tensor: Self::Primitive, axes: &[usize]) -> Self::Primitive {
  method unfold (line 187) | fn unfold(tensor: Self::Primitive, dim: usize, size: usize, step: usize)...
  method add (line 193) | fn add(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive {
  method add_scalar (line 196) | fn add_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive {
  method sub (line 199) | fn sub(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive {
  method sub_scalar (line 202) | fn sub_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive {
  method div (line 205) | fn div(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive {
  method div_scalar (line 208) | fn div_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive {
  method remainder (line 211) | fn remainder(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primit...
  method remainder_scalar (line 214) | fn remainder_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive {
  method mul (line 217) | fn mul(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive {
  method mul_scalar (line 220) | fn mul_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive {
  method neg (line 223) | fn neg(tensor: Self::Primitive) -> Self::Primitive {
  method sum (line 227) | fn sum(tensor: Self::Primitive) -> Self::Primitive {
  method sum_dim (line 231) | fn sum_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method prod (line 235) | fn prod(tensor: Self::Primitive) -> Self::Primitive {
  method prod_dim (line 239) | fn prod_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method mean (line 243) | fn mean(tensor: Self::Primitive) -> Self::Primitive {
  method mean_dim (line 246) | fn mean_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method cumsum (line 249) | fn cumsum(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method cumprod (line 252) | fn cumprod(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method abs (line 256) | fn abs(tensor: Self::Primitive) -> Self::Primitive {
  method powi (line 260) | fn powi(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive {
  method powi_scalar (line 264) | fn powi_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive {
  method random (line 268) | fn random(shape: Shape, distribution: Distribution, device: &Device<B>) ...
  method sign (line 272) | fn sign(tensor: Self::Primitive) -> Self::Primitive {
  method matmul (line 283) | fn matmul(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive {
  method sort (line 289) | fn sort(tensor: Self::Primitive, dim: usize, descending: bool) -> Self::...
  method sort_with_indices (line 293) | fn sort_with_indices(
  method argsort (line 301) | fn argsort(tensor: Self::Primitive, dim: usize, descending: bool) -> Int...
  method cummin (line 305) | fn cummin(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method cummax (line 309) | fn cummax(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method greater (line 313) | fn greater(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTensorP...
  method greater_elem (line 317) | fn greater_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorPrimi...
  method greater_equal (line 321) | fn greater_equal(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolT...
  method greater_equal_elem (line 325) | fn greater_equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTenso...
  method lower (line 329) | fn lower(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTensorPri...
  method lower_elem (line 333) | fn lower_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorPrimiti...
  method lower_equal (line 337) | fn lower_equal(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTen...
  method lower_equal_elem (line 341) | fn lower_equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorP...
  method argmax (line 345) | fn argmax(tensor: Self::Primitive, dim: usize) -> IntTensor<B> {
  method argmin (line 349) | fn argmin(tensor: Self::Primitive, dim: usize) -> IntTensor<B> {
  method max (line 353) | fn max(tensor: Self::Primitive) -> Self::Primitive {
  method max_dim (line 357) | fn max_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method max_dim_with_indices (line 361) | fn max_dim_with_indices(
  method max_abs (line 368) | fn max_abs(tensor: Self::Primitive) -> Self::Primitive {
  method max_abs_dim (line 372) | fn max_abs_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method min (line 376) | fn min(tensor: Self::Primitive) -> Self::Primitive {
  method min_dim (line 380) | fn min_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive {
  method min_dim_with_indices (line 384) | fn min_dim_with_indices(
  method clamp (line 391) | fn clamp(tensor: Self::Primitive, min: Scalar, max: Scalar) -> Self::Pri...
  method clamp_min (line 395) | fn clamp_min(tensor: Self::Primitive, min: Scalar) -> Self::Primitive {
  method clamp_max (line 399) | fn clamp_max(tensor: Self::Primitive, max: Scalar) -> Self::Primitive {
  type InnerKind (line 405) | type InnerKind = Int;
  method inner (line 407) | fn inner(
  method from_inner (line 413) | fn from_inner(

FILE: crates/burn-backend/src/tensor/ops/mod.rs
  type IndexingUpdateOp (line 16) | pub enum IndexingUpdateOp {

FILE: crates/burn-backend/src/tensor/ops/numeric.rs
  type Numeric (line 13) | pub trait Numeric<B: Backend>: BasicOps<B>
    method add (line 38) | fn add(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;
    method add_scalar (line 61) | fn add_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive;
    method sub (line 84) | fn sub(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;
    method sub_scalar (line 107) | fn sub_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive;
    method div (line 130) | fn div(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;
    method div_scalar (line 153) | fn div_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive;
    method remainder (line 177) | fn remainder(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Prim...
    method remainder_scalar (line 201) | fn remainder_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primit...
    method mul (line 224) | fn mul(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;
    method mul_scalar (line 247) | fn mul_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive;
    method neg (line 269) | fn neg(tensor: Self::Primitive) -> Self::Primitive;
    method sign (line 291) | fn sign(tensor: Self::Primitive) -> Self::Primitive;
    method sum (line 313) | fn sum(tensor: Self::Primitive) -> Self::Primitive;
    method sum_dim (line 336) | fn sum_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    method prod (line 358) | fn prod(tensor: Self::Primitive) -> Self::Primitive;
    method prod_dim (line 381) | fn prod_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    method mean (line 403) | fn mean(tensor: Self::Primitive) -> Self::Primitive;
    method mean_dim (line 426) | fn mean_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    method cumsum (line 450) | fn cumsum(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    method cumprod (line 474) | fn cumprod(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    method abs (line 496) | fn abs(tensor: Self::Primitive) -> Self::Primitive;
    method powi (line 503) | fn powi(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;
    method powi_scalar (line 510) | fn powi_scalar(lhs: Self::Primitive, rhs: Scalar) -> Self::Primitive;
    method random (line 534) | fn random(shape: Shape, distribution: Distribution, device: &B::Device...
    method matmul (line 541) | fn matmul(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;

FILE: crates/burn-backend/src/tensor/ops/ordered.rs
  type Ordered (line 19) | pub trait Ordered<B: Backend>: Numeric<B> {
    method sort (line 43) | fn sort(tensor: Self::Primitive, dim: usize, descending: bool) -> Self...
    method sort_with_indices (line 69) | fn sort_with_indices(
    method argsort (line 98) | fn argsort(tensor: Self::Primitive, dim: usize, descending: bool) -> I...
    method cummin (line 122) | fn cummin(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    method cummax (line 146) | fn cummax(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    method greater (line 171) | fn greater(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTenso...
    method greater_elem (line 196) | fn greater_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorPri...
    method greater_equal (line 221) | fn greater_equal(lhs: Self::Primitive, rhs: Self::Primitive) -> B::Boo...
    method greater_equal_elem (line 246) | fn greater_equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTen...
    method lower (line 271) | fn lower(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTensorP...
    method lower_elem (line 296) | fn lower_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTensorPrimi...
    method lower_equal (line 321) | fn lower_equal(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolT...
    method lower_equal_elem (line 346) | fn lower_equal_elem(lhs: Self::Primitive, rhs: Scalar) -> B::BoolTenso...
    method argmax (line 370) | fn argmax(tensor: Self::Primitive, dim: usize) -> IntTensor<B>;
    method argmin (line 394) | fn argmin(tensor: Self::Primitive, dim: usize) -> IntTensor<B>;
    method max (line 416) | fn max(tensor: Self::Primitive) -> Self::Primitive;
    method max_dim (line 440) | fn max_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    method max_dim_with_indices (line 465) | fn max_dim_with_indices(tensor: Self::Primitive, dim: usize)
    method max_abs (line 488) | fn max_abs(tensor: Self::Primitive) -> Self::Primitive;
    method max_abs_dim (line 512) | fn max_abs_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    method min (line 534) | fn min(tensor: Self::Primitive) -> Self::Primitive;
    method min_dim (line 558) | fn min_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    method min_dim_with_indices (line 582) | fn min_dim_with_indices(tensor: Self::Primitive, dim: usize)
    method clamp (line 605) | fn clamp(tensor: Self::Primitive, min: Scalar, max: Scalar) -> Self::P...
    method clamp_min (line 627) | fn clamp_min(tensor: Self::Primitive, min: Scalar) -> Self::Primitive;
    method clamp_max (line 649) | fn clamp_max(tensor: Self::Primitive, max: Scalar) -> Self::Primitive;

FILE: crates/burn-backend/src/tensor/quantization/calibration.rs
  type Calibration (line 2) | pub enum Calibration {

FILE: crates/burn-backend/src/tensor/quantization/parameters.rs
  type QuantizationParametersPrimitive (line 12) | pub struct QuantizationParametersPrimitive<B: Backend> {

FILE: crates/burn-backend/src/tensor/quantization/scheme.rs
  function compute_range (line 8) | pub fn compute_range<B: Backend>(
  function compute_q_params (line 42) | pub fn compute_q_params<B: Backend>(

FILE: crates/burn-candle/src/backend.rs
  type Candle (line 23) | pub struct Candle<F = f32, I = i64>
  function get_seeded_rng (line 35) | pub(crate) fn get_seeded_rng() -> StdRng {
  function set_seeded_rng (line 40) | pub(crate) fn set_seeded_rng(rng_seeded: StdRng) {
  type CandleDevice (line 59) | pub enum CandleDevice {
    method cuda (line 76) | pub fn cuda(index: usize) -> Self {
    method metal (line 85) | pub fn metal(index: usize) -> Self {
    method set_seed (line 92) | pub(crate) fn set_seed(&self, seed: u64) {
    method from (line 149) | fn from(device: candle_core::Device) -> Self {
    method to_id (line 177) | fn to_id(&self) -> burn_backend::DeviceId {
    method from_id (line 185) | fn from_id(device_id: DeviceId) -> Self {
    method device_count (line 193) | fn device_count(type_id: u16) -> usize {
  type CudaDevice (line 108) | pub struct CudaDevice {
  method eq (line 115) | fn eq(&self, other: &Self) -> bool {
  type MetalDevice (line 124) | pub struct MetalDevice {
  method eq (line 131) | fn eq(&self, other: &Self) -> bool {
  function from (line 139) | fn from(device: CandleDevice) -> Self {
  type Device (line 201) | type Device = CandleDevice;
  type FloatTensorPrimitive (line 203) | type FloatTensorPrimitive = CandleTensor;
  type FloatElem (line 204) | type FloatElem = F;
  type IntTensorPrimitive (line 206) | type IntTensorPrimitive = CandleTensor;
  type IntElem (line 207) | type IntElem = I;
  type BoolTensorPrimitive (line 209) | type BoolTensorPrimitive = CandleTensor;
  type BoolElem (line 210) | type BoolElem = u8;
  type QuantizedTensorPrimitive (line 212) | type QuantizedTensorPrimitive = CandleTensor;
  method ad_enabled (line 214) | fn ad_enabled(_device: &Self::Device) -> bool {
  method name (line 218) | fn name(device: &Self::Device) -> String {
  method seed (line 227) | fn seed(device: &CandleDevice, seed: u64) {
  method sync (line 231) | fn sync(device: &Device<Self>) -> Result<(), ExecutionError> {
  method dtype_usage (line 260) | fn dtype_usage(device: &Self::Device, dtype: DType) -> burn_backend::DTy...
  function should_support_dtypes (line 276) | fn should_support_dtypes() {

FILE: crates/burn-candle/src/element.rs
  type CandleElement (line 7) | pub trait CandleElement: Element + WithDType {}
  type FloatCandleElement (line 9) | pub trait FloatCandleElement: CandleElement + FloatDType {}
  type IntCandleElement (line 11) | pub trait IntCandleElement: CandleElement {}

FILE: crates/burn-candle/src/ops/activation.rs
  function gelu (line 10) | fn gelu(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function relu (line 14) | fn relu(tensor: FloatTensor<Self>) -> FloatTensor<Self> {

FILE: crates/burn-candle/src/ops/base.rs
  function cpu_random (line 17) | pub fn cpu_random<E: CandleElement>(shape: Shape, distribution: Distribu...
  function cat (line 24) | pub fn cat(tensors: Vec<CandleTensor>, dim: usize) -> CandleTensor {
  function from_data (line 29) | pub fn from_data<E: CandleElement>(data: TensorData, device: &CandleDevi...
  function into_data (line 32) | pub fn into_data(tensor: CandleTensor) -> Result<TensorData, ExecutionEr...
  function to_device (line 65) | pub fn to_device(tensor: CandleTensor, device: &CandleDevice) -> CandleT...
  function empty (line 69) | pub fn empty(shape: Shape, device: &CandleDevice, dtype: candle_core::DT...
  function zeros (line 73) | pub fn zeros(shape: Shape, device: &CandleDevice, dtype: candle_core::DT...
  function ones (line 79) | pub fn ones(shape: Shape, device: &CandleDevice, dtype: candle_core::DTy...
  function swap_dims (line 85) | pub fn swap_dims(mut tensor: CandleTensor, dim1: usize, dim2: usize) -> ...
  function permute (line 89) | pub fn permute(tensor: CandleTensor, axes: &[usize]) -> CandleTensor {
  function flip (line 93) | pub fn flip(tensor: CandleTensor, axes: &[usize]) -> CandleTensor {
  function reshape (line 113) | pub fn reshape(tensor: CandleTensor, shape: Shape) -> CandleTensor {
  function device (line 117) | pub fn device(tensor: &CandleTensor) -> CandleDevice {
  function shape (line 121) | pub fn shape(tensor: &CandleTensor) -> Shape {
  function slice (line 125) | pub fn slice(tensor: CandleTensor, ranges: &[std::ops::Range<usize>]) ->...
  function slice_with_steps (line 135) | pub fn slice_with_steps(tensor: CandleTensor, slices: &[Slice]) -> Candl...
  function slice_assign (line 195) | pub fn slice_assign(tensor: CandleTensor, slices: &[Slice], value: Candl...
  function slice_assign_with_steps_workaround (line 218) | fn slice_assign_with_steps_workaround(
  function generate_slice_indices (line 277) | fn generate_slice_indices(slices: &[Slice], tensor_dims: &[usize]) -> Ve...
  function generate_stepped_indices (line 298) | fn generate_stepped_indices(start: usize, end: usize, step: isize) -> Ve...
  function compute_flat_index (line 324) | fn compute_flat_index(
  function narrow (line 345) | pub fn narrow(tensor: CandleTensor, dim: usize, start: usize, length: us...
  function chunk (line 353) | pub fn chunk(tensor: CandleTensor, chunks: usize, dim: usize) -> Vec<Can...
  function expand (line 361) | pub fn expand(tensor: CandleTensor, shape: Shape) -> CandleTensor {
  function unfold (line 365) | pub fn unfold(tensor: CandleTensor, dim: usize, size: usize, step: usize...
  function sign (line 388) | pub fn sign(tensor: CandleTensor) -> CandleTensor {
  function mask_where_broadcasted (line 392) | pub fn mask_where_broadcasted(
  function cross (line 420) | pub fn cross(lhs: CandleTensor, rhs: CandleTensor, dim: usize) -> Candle...

FILE: crates/burn-candle/src/ops/bool_tensor.rs
  function bool_empty (line 15) | fn bool_empty(shape: Shape, device: &Device<Self>) -> BoolTensor<Self> {
  function bool_zeros (line 19) | fn bool_zeros(shape: Shape, device: &Device<Self>) -> BoolTensor<Self> {
  function bool_ones (line 23) | fn bool_ones(shape: Shape, device: &Device<Self>) -> BoolTensor<Self> {
  function bool_into_data (line 27) | async fn bool_into_data(tensor: BoolTensor<Self>) -> Result<TensorData, ...
  function bool_from_data (line 46) | fn bool_from_data(data: TensorData, device: &Device<Self>) -> BoolTensor...
  function bool_into_int (line 53) | fn bool_into_int(tensor: BoolTensor<Self>) -> IntTensor<Self> {
  function bool_into_float (line 57) | fn bool_into_float(tensor: BoolTensor<Self>) -> FloatTensor<Self> {
  function bool_device (line 61) | fn bool_device(tensor: &BoolTensor<Self>) -> Device<Self> {
  function bool_to_device (line 65) | fn bool_to_device(tensor: BoolTensor<Self>, device: &Device<Self>) -> Bo...
  function bool_reshape (line 69) | fn bool_reshape(tensor: BoolTensor<Self>, shape: Shape) -> BoolTensor<Se...
  function bool_slice (line 73) | fn bool_slice(tensor: BoolTensor<Self>, slices: &[Slice]) -> BoolTensor<...
  function bool_slice_assign (line 77) | fn bool_slice_assign(
  function bool_cat (line 85) | fn bool_cat(tensors: Vec<BoolTensor<Self>>, dim: usize) -> BoolTensor<Se...
  function bool_equal (line 89) | fn bool_equal(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTenso...
  function bool_not (line 95) | fn bool_not(tensor: BoolTensor<Self>) -> BoolTensor<Self> {
  function bool_and (line 100) | fn bool_and(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTensor<...
  function bool_or (line 105) | fn bool_or(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTensor<S...
  function bool_swap_dims (line 115) | fn bool_swap_dims(tensor: BoolTensor<Self>, dim1: usize, dim2: usize) ->...
  function bool_permute (line 119) | fn bool_permute(tensor: BoolTensor<Self>, axes: &[usize]) -> BoolTensor<...
  function bool_flip (line 123) | fn bool_flip(tensor: BoolTensor<Self>, axes: &[usize]) -> BoolTensor<Sel...
  function bool_select (line 127) | fn bool_select(
  function bool_select_or (line 135) | fn bool_select_or(
  function bool_expand (line 149) | fn bool_expand(tensor: BoolTensor<Self>, shape: Shape) -> BoolTensor<Sel...
  function bool_unfold (line 153) | fn bool_unfold(
  function bool_mask_where (line 162) | fn bool_mask_where(
  function bool_mask_fill (line 170) | fn bool_mask_fill(
  function bool_gather (line 185) | fn bool_gather(
  function bool_scatter_or (line 195) | fn bool_scatter_or(
  function bool_equal_elem (line 209) | fn bool_equal_elem(lhs: BoolTensor<Self>, rhs: Scalar) -> BoolTensor<Sel...

FILE: crates/burn-candle/src/ops/candle_utils.rs
  function fill (line 5) | pub(crate) fn fill<E: CandleElement, S: Into<Shape>>(
  function fill_like (line 15) | pub(crate) fn fill_like<E: CandleElement>(value: E, reference_tensor: &T...
  function broadcast_for_comparison (line 25) | pub(crate) fn broadcast_for_comparison(

FILE: crates/burn-candle/src/ops/int_tensor.rs
  function int_empty (line 16) | fn int_empty(shape: Shape, device: &Device<Self>, dtype: IntDType) -> In...
  function int_into_data (line 20) | async fn int_into_data(tensor: IntTensor<Self>) -> Result<TensorData, Ex...
  function int_from_data (line 24) | fn int_from_data(data: TensorData, device: &Device<Self>) -> IntTensor<S...
  function int_device (line 33) | fn int_device(tensor: &IntTensor<Self>) -> Device<Self> {
  function int_to_device (line 37) | fn int_to_device(tensor: IntTensor<Self>, device: &Device<Self>) -> IntT...
  function int_reshape (line 41) | fn int_reshape(tensor: IntTensor<Self>, shape: Shape) -> IntTensor<Self> {
  function int_slice (line 45) | fn int_slice(tensor: IntTensor<Self>, slices: &[Slice]) -> IntTensor<Sel...
  function int_slice_assign (line 49) | fn int_slice_assign(
  function int_into_float (line 57) | fn int_into_float(tensor: IntTensor<Self>) -> FloatTensor<Self> {
  function int_mask_where (line 61) | fn int_mask_where(
  function int_mask_fill (line 69) | fn int_mask_fill(
  function int_gather (line 84) | fn int_gather(
  function int_scatter_add (line 94) | fn int_scatter_add(
  function int_select (line 108) | fn int_select(
  function int_select_add (line 116) | fn int_select_add(
  function int_cat (line 130) | fn int_cat(tensors: Vec<IntTensor<Self>>, dim: usize) -> IntTensor<Self> {
  function int_equal (line 134) | fn int_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor<S...
  function int_equal_elem (line 140) | fn int_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Self> {
  function int_greater (line 144) | fn int_greater(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor...
  function int_greater_elem (line 150) | fn int_greater_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Sel...
  function int_greater_equal (line 161) | fn int_greater_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> Bool...
  function int_greater_equal_elem (line 167) | fn int_greater_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTens...
  function int_lower (line 178) | fn int_lower(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor<S...
  function int_lower_elem (line 184) | fn int_lower_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Self> {
  function int_lower_equal (line 195) | fn int_lower_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTe...
  function int_lower_equal_elem (line 201) | fn int_lower_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor...
  function int_add (line 212) | fn int_add(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_add_scalar (line 216) | fn int_add_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_sub (line 220) | fn int_sub(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_sub_scalar (line 224) | fn int_sub_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_mul (line 228) | fn int_mul(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_mul_scalar (line 232) | fn int_mul_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_div (line 236) | fn int_div(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_div_scalar (line 240) | fn int_div_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_remainder (line 245) | fn int_remainder(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTenso...
  function int_remainder_scalar (line 258) | fn int_remainder_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<...
  function int_zeros (line 263) | fn int_zeros(shape: Shape, device: &Device<Self>, dtype: IntDType) -> In...
  function int_ones (line 274) | fn int_ones(shape: Shape, device: &Device<Self>, dtype: IntDType) -> Int...
  function int_sum (line 281) | fn int_sum(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_sum_dim (line 289) | fn int_sum_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_prod (line 293) | fn int_prod(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_prod_dim (line 299) | fn int_prod_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_mean_dim (line 305) | fn int_mean_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cumsum (line 310) | fn int_cumsum(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cumprod (line 319) | fn int_cumprod(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cummin (line 330) | fn int_cummin(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cummax (line 341) | fn int_cummax(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_argmax (line 348) | fn int_argmax(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_argmin (line 359) | fn int_argmin(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_abs (line 370) | fn int_abs(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_swap_dims (line 388) | fn int_swap_dims(tensor: IntTensor<Self>, dim1: usize, dim2: usize) -> I...
  function int_random (line 392) | fn int_random(
  function int_permute (line 436) | fn int_permute(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Sel...
  function int_flip (line 440) | fn int_flip(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Self> {
  function int_expand (line 444) | fn int_expand(tensor: IntTensor<Self>, shape: Shape) -> IntTensor<Self> {
  function int_unfold (line 448) | fn int_unfold(
  function int_sign (line 457) | fn int_sign(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function bitwise_and (line 460) | fn bitwise_and(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  function bitwise_and_scalar (line 464) | fn bitwise_and_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  function bitwise_or (line 468) | fn bitwise_or(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  function bitwise_or_scalar (line 472) | fn bitwise_or_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Sel...
  function bitwise_xor (line 476) | fn bitwise_xor(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  function bitwise_xor_scalar (line 480) | fn bitwise_xor_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  function bitwise_not (line 484) | fn bitwise_not(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function bitwise_left_shift (line 488) | fn bitwise_left_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> Int...
  function bitwise_right_shift (line 492) | fn bitwise_right_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> In...
  function bitwise_left_shift_scalar (line 496) | fn bitwise_left_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTe...
  function bitwise_right_shift_scalar (line 500) | fn bitwise_right_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntT...
  function int_matmul (line 504) | fn int_matmul(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  function int_cast (line 512) | fn int_cast(tensor: IntTensor<Self>, dtype: IntDType) -> IntTensor<Self> {

FILE: crates/burn-candle/src/ops/module.rs
  function conv1d (line 19) | fn conv1d(
  function conv2d (line 43) | fn conv2d(
  function deform_conv2d (line 82) | fn deform_conv2d(
  function deform_conv2d_backward (line 93) | fn deform_conv2d_backward(
  function conv3d (line 105) | fn conv3d(
  function conv_transpose1d (line 114) | fn conv_transpose1d(
  function conv_transpose2d (line 139) | fn conv_transpose2d(
  function conv_transpose3d (line 183) | fn conv_transpose3d(
  function avg_pool2d (line 192) | fn avg_pool2d(
  function avg_pool2d_backward (line 216) | fn avg_pool2d_backward(
  function max_pool2d (line 228) | fn max_pool2d(
  function max_pool2d_with_indices (line 252) | fn max_pool2d_with_indices(
  function max_pool2d_with_indices_backward (line 263) | fn max_pool2d_with_indices_backward(
  function adaptive_avg_pool2d (line 276) | fn adaptive_avg_pool2d(x: FloatTensor<Self>, output_size: [usize; 2]) ->...
  function adaptive_avg_pool2d_backward (line 280) | fn adaptive_avg_pool2d_backward(
  function interpolate (line 287) | fn interpolate(
  function interpolate_backward (line 311) | fn interpolate_backward(
  function attention (line 320) | fn attention(

FILE: crates/burn-candle/src/ops/qtensor.rs
  function q_from_data (line 14) | fn q_from_data(data: TensorData, device: &Device<Self>) -> QuantizedTens...
  function quantize (line 18) | fn quantize(
  function dequantize (line 26) | fn dequantize(_tensor: QuantizedTensor<Self>) -> FloatTensor<Self> {
  function q_device (line 30) | fn q_device(_tensor: &QuantizedTensor<Self>) -> Device<Self> {
  function q_to_device (line 34) | fn q_to_device(
  function q_reshape (line 41) | fn q_reshape(_tensor: QuantizedTensor<Self>, _shape: Shape) -> Quantized...
  function q_into_data (line 45) | async fn q_into_data(tensor: QuantizedTensor<Self>) -> Result<TensorData...
  function q_swap_dims (line 49) | fn q_swap_dims(
  function q_permute (line 57) | fn q_permute(_tensor: QuantizedTensor<Self>, _axes: &[usize]) -> Quantiz...
  function q_flip (line 61) | fn q_flip(_tensor: QuantizedTensor<Self>, _axes: &[usize]) -> QuantizedT...
  function q_gather (line 65) | fn q_gather(
  function q_select (line 73) | fn q_select(
  function q_slice (line 81) | fn q_slice(_tensor: QuantizedTensor<Self>, _slices: &[Slice]) -> Quantiz...
  function q_expand (line 85) | fn q_expand(_tensor: QuantizedTensor<Self>, _shape: Shape) -> QuantizedT...

FILE: crates/burn-candle/src/ops/tensor.rs
  function float_from_data (line 19) | fn float_from_data(data: TensorData, device: &Device<Self>) -> CandleTen...
  function float_random (line 29) | fn float_random(
  function float_into_data (line 68) | async fn float_into_data(tensor: CandleTensor) -> Result<TensorData, Exe...
  function float_device (line 72) | fn float_device(tensor: &CandleTensor) -> Device<Self> {
  function float_to_device (line 76) | fn float_to_device(tensor: CandleTensor, device: &Device<Self>) -> Candl...
  function float_into_int (line 80) | fn float_into_int(tensor: CandleTensor) -> IntTensor<Self> {
  function float_empty (line 84) | fn float_empty(shape: Shape, device: &Device<Self>, dtype: FloatDType) -...
  function float_add (line 88) | fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_add_scalar (line 92) | fn float_add_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_sub (line 96) | fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_sub_scalar (line 100) | fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_mul (line 104) | fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_mul_scalar (line 108) | fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_div (line 112) | fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_div_scalar (line 116) | fn float_div_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_remainder (line 120) | fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Fl...
  function float_remainder_scalar (line 135) | fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatT...
  function float_matmul (line 144) | fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Float...
  function float_cross (line 158) | fn float_cross(
  function float_swap_dims (line 166) | fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) ...
  function float_reshape (line 170) | fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor...
  function float_gather (line 174) | fn float_gather(
  function float_scatter_add (line 184) | fn float_scatter_add(
  function float_select (line 198) | fn float_select(
  function float_select_add (line 206) | fn float_select_add(
  function float_slice (line 220) | fn float_slice(tensor: FloatTensor<Self>, slices: &[Slice]) -> FloatTens...
  function float_slice_assign (line 224) | fn float_slice_assign(
  function float_mask_where (line 232) | fn float_mask_where(
  function float_mask_fill (line 240) | fn float_mask_fill(
  function float_equal (line 249) | fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTe...
  function float_equal_elem (line 255) | fn float_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor<S...
  function float_greater (line 259) | fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Bool...
  function float_greater_elem (line 265) | fn float_greater_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor...
  function float_greater_equal (line 276) | fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -...
  function float_greater_equal_elem (line 282) | fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> Bool...
  function float_lower (line 293) | fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTe...
  function float_lower_elem (line 299) | fn float_lower_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor<S...
  function float_lower_equal (line 310) | fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> ...
  function float_lower_equal_elem (line 316) | fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTe...
  function float_sum (line 327) | fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sum_dim (line 335) | fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_mean_dim (line 339) | fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<...
  function float_cumsum (line 343) | fn float_cumsum(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_cumprod (line 347) | fn float_cumprod(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_cummin (line 354) | fn float_cummin(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_cummax (line 361) | fn float_cummax(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_exp (line 368) | fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_log (line 372) | fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_log1p (line 376) | fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_powf_scalar_impl (line 380) | fn float_powf_scalar_impl(tensor: FloatTensor<Self>, value: Scalar) -> F...
  function float_sqrt (line 384) | fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_abs (line 388) | fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cos (line 392) | fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cosh (line 396) | fn float_cosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sin (line 402) | fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sinh (line 406) | fn float_sinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_tan (line 412) | fn float_tan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_tanh (line 416) | fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_acos (line 420) | fn float_acos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_acosh (line 426) | fn float_acosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asin (line 434) | fn float_asin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asinh (line 442) | fn float_asinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan (line 450) | fn float_atan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atanh (line 458) | fn float_atanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan2 (line 465) | fn float_atan2(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatT...
  function float_round (line 474) | fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_floor (line 496) | fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_ceil (line 500) | fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_trunc (line 504) | fn float_trunc(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_erf (line 513) | fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cat (line 517) | fn float_cat(tensors: Vec<FloatTensor<Self>>, dim: usize) -> FloatTensor...
  function float_argmax (line 521) | fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {
  function float_argmin (line 532) | fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {
  function float_clamp_max (line 543) | fn float_clamp_max(tensor: FloatTensor<Self>, max: Scalar) -> FloatTenso...
  function float_clamp_min (line 547) | fn float_clamp_min(tensor: FloatTensor<Self>, min: Scalar) -> FloatTenso...
  function float_clamp (line 551) | fn float_clamp(tensor: FloatTensor<Self>, min: Scalar, max: Scalar) -> F...
  function float_recip (line 560) | fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_powf (line 564) | fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTe...
  function float_permute (line 578) | fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTens...
  function float_flip (line 582) | fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<...
  function float_expand (line 586) | fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<...
  function float_unfold (line 590) | fn float_unfold(
  function float_sign (line 599) | fn float_sign(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cast (line 603) | fn float_cast(tensor: FloatTensor<Self>, dtype: FloatDType) -> FloatTens...

FILE: crates/burn-candle/src/ops/utils.rs
  function cumulative_with_op (line 11) | pub fn cumulative_with_op<F>(tensor: &candle_core::Tensor, dim: usize, o...

FILE: crates/burn-candle/src/tensor.rs
  type CandleTensor (line 9) | pub struct CandleTensor {
    method new (line 46) | pub fn new(tensor: candle_core::Tensor) -> Self {
    method from_data (line 60) | pub fn from_data<E: CandleElement>(data: TensorData, device: CandleDev...
  method dtype (line 14) | fn dtype(&self) -> DType {
  method shape (line 29) | fn shape(&self) -> Shape {
  method rank (line 33) | fn rank(&self) -> usize {
  method scheme (line 39) | fn scheme(&self) -> &QuantScheme {
  type IntoDType (line 71) | pub(crate) trait IntoDType {
    method try_into_dtype (line 72) | fn try_into_dtype(self) -> Result<candle_core::DType, candle_core::Err...
    method into_dtype (line 74) | fn into_dtype(self) -> candle_core::DType
    method try_into_dtype (line 83) | fn try_into_dtype(self) -> Result<candle_core::DType, candle_core::Err...
    method try_into_dtype (line 90) | fn try_into_dtype(self) -> Result<candle_core::DType, candle_core::Err...
    method try_into_dtype (line 97) | fn try_into_dtype(self) -> Result<candle_core::DType, candle_core::Err...

FILE: crates/burn-collective/multinode-tests/src/bin/global.rs
  function main (line 12) | pub async fn main() {

FILE: crates/burn-collective/multinode-tests/src/bin/node.rs
  type TestBackend (line 23) | type TestBackend = NdArray;
  type TestChannel (line 26) | type TestChannel = tokio_serde::Framed<
  function main (line 37) | pub async fn main() {
  function run_test (line 63) | fn run_test<B: Backend>(test_input: &NodeTest) -> NodeTestResult {
  function launch_threads (line 95) | fn launch_threads<B: Backend>(
  function run_peer (line 134) | pub fn run_peer<B: Backend>(

FILE: crates/burn-collective/multinode-tests/src/bin/test_launcher.rs
  type AllReduceTest (line 22) | struct AllReduceTest {
  method fmt (line 30) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type TestChannel (line 51) | type TestChannel = tokio_serde::Framed<
  type NodeProcessHandle (line 59) | struct NodeProcessHandle {
  function main (line 67) | async fn main() {
  function launch_orchestrator (line 150) | fn launch_orchestrator(test_files_dir: &str) -> Child {
  function launch_nodes (line 165) | async fn launch_nodes(
  function test_all_reduce (line 222) | async fn test_all_reduce(
  function dispatch_all_reduce_test (line 247) | async fn dispatch_all_reduce_test(
  function test_all_reduce_centralized_no_collective (line 296) | fn test_all_reduce_centralized_no_collective<B: Backend>(
  function generate_random_input (line 323) | fn generate_random_input(

FILE: crates/burn-collective/multinode-tests/src/shared.rs
  constant TENSOR_RANK (line 9) | pub const TENSOR_RANK: usize = 3;
  type NodeTest (line 12) | pub struct NodeTest {
  type NodeTestResult (line 40) | pub struct NodeTestResult {

FILE: crates/burn-collective/src/api.rs
  type CollectiveError (line 11) | pub enum CollectiveError {
  function register (line 54) | pub fn register<B: Backend>(
  function all_reduce (line 70) | pub fn all_reduce<B: Backend>(
  function broadcast (line 86) | pub fn broadcast<B: Backend>(
  function reduce (line 101) | pub fn reduce<B: Backend>(
  function finish_collective (line 112) | pub fn finish_collective<B: Backend>(id: PeerId) -> Result<(), Collectiv...
  function reset_collective (line 118) | pub fn reset_collective<B: Backend>() {

FILE: crates/burn-collective/src/config.rs
  type CollectiveConfig (line 10) | pub struct CollectiveConfig {
    method new (line 70) | fn new() -> Self {
    method with_num_devices (line 88) | pub fn with_num_devices(mut self, num: usize) -> Self {
    method with_local_all_reduce_strategy (line 102) | pub fn with_local_all_reduce_strategy(mut self, strategy: AllReduceStr...
    method with_local_reduce_strategy (line 108) | pub fn with_local_reduce_strategy(mut self, strategy: ReduceStrategy) ...
    method with_local_broadcast_strategy (line 114) | pub fn with_local_broadcast_strategy(mut self, strategy: BroadcastStra...
    method with_num_nodes (line 122) | pub fn with_num_nodes(mut self, n: u32) -> Self {
    method with_global_address (line 130) | pub fn with_global_address(mut self, addr: Address) -> Self {
    method with_node_address (line 138) | pub fn with_node_address(mut self, addr: Address) -> Self {
    method with_data_service_port (line 147) | pub fn with_data_service_port(mut self, port: u16) -> Self {
    method with_global_all_reduce_strategy (line 156) | pub fn with_global_all_reduce_strategy(mut self, strategy: AllReduceSt...
    method with_global_reduce_strategy (line 165) | pub fn with_global_reduce_strategy(mut self, strategy: ReduceStrategy)...
    method with_global_broadcast_strategy (line 174) | pub fn with_global_broadcast_strategy(mut self, strategy: BroadcastStr...
    method is_valid (line 181) | pub fn is_valid(&self) -> bool {
    method global_register_params (line 199) | pub(crate) fn global_register_params(&self) -> Option<GlobalRegisterPa...
  method default (line 29) | fn default() -> Self {
  method fmt (line 35) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type GlobalRegisterParams (line 227) | pub struct GlobalRegisterParams {
  type SharedAllReduceParams (line 242) | pub struct SharedAllReduceParams {
  type SharedReduceParams (line 250) | pub struct SharedReduceParams {}
  type SharedBroadcastParams (line 254) | pub struct SharedBroadcastParams {
  type ReduceOperation (line 262) | pub enum ReduceOperation {
  type AllReduceStrategy (line 269) | pub enum AllReduceStrategy {
  type ReduceStrategy (line 290) | pub enum ReduceStrategy {
  type BroadcastStrategy (line 300) | pub enum BroadcastStrategy {
  type PeerId (line 313) | pub struct PeerId(u32);
    method from (line 322) | fn from(value: u32) -> Self {
    method from (line 328) | fn from(value: i32) -> Self {
    method from (line 334) | fn from(value: usize) -> Self {
  method fmt (line 316) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: crates/burn-collective/src/global/base.rs
  type NodeId (line 5) | pub struct NodeId(u32);
    method from (line 8) | fn from(value: u32) -> Self {
    method from (line 14) | fn from(value: usize) -> Self {
    method from (line 20) | fn from(value: i32) -> Self {

FILE: crates/burn-collective/src/global/node/base.rs
  type NodeState (line 27) | pub(crate) struct NodeState {
  type Node (line 34) | pub(crate) struct Node<B, P>
  function new (line 53) | pub fn new(global_address: &Address, comms_server: P::Server) -> Self {
  function register (line 86) | pub async fn register(
  function all_reduce (line 124) | pub async fn all_reduce(
  function reduce (line 178) | pub async fn reduce(
  function broadcast (line 188) | pub async fn broadcast(
  function finish (line 196) | pub async fn finish(&mut self) {

FILE: crates/burn-collective/src/global/node/centralized.rs
  function centralized_all_reduce_sum (line 14) | pub(crate) async fn centralized_all_reduce_sum<B, P>(
  function get_central_node (line 92) | pub(crate) fn get_central_node(mut nodes: Vec<NodeId>) -> NodeId {

FILE: crates/burn-collective/src/global/node/ring.rs
  function ring_all_reduce_sum (line 53) | pub(crate) async fn ring_all_reduce_sum<B, P>(
  function do_cycles (line 124) | async fn do_cycles<B, P>(
  function slice_tensor (line 186) | fn slice_tensor<B: Backend>(
  function get_ring_topology (line 211) | fn get_ring_topology(mut nodes: Vec<NodeId>) -> Vec<NodeId> {

FILE: crates/burn-collective/src/global/node/sync.rs
  type SyncService (line 14) | pub(crate) struct SyncService<P: Protocol> {
  type SyncRequest (line 26) | struct SyncRequest(NodeId);
  function new (line 29) | pub fn new(node_state: Arc<RwLock<Option<NodeState>>>) -> Self {
  function add_syncing_peer (line 38) | fn add_syncing_peer(&self, peer: NodeId) {
  function sync (line 44) | pub async fn sync(&self) {
  function handle_sync_connection (line 88) | pub async fn handle_sync_connection<C: CommunicationChannel>(&self, mut ...

FILE: crates/burn-collective/src/global/node/tree.rs
  type TreeTopology (line 8) | struct TreeTopology {
  function tree_all_reduce_sum (line 16) | pub(crate) async fn tree_all_reduce_sum<B, P>(
  function get_tree_topology (line 100) | fn get_tree_topology(mut nodes: Vec<NodeId>, arity: u32) -> TreeTopology {
  function test_get_tree_topology_arity2_size7 (line 137) | fn test_get_tree_topology_arity2_size7() {

FILE: crates/burn-collective/src/global/node/worker.rs
  type GlobalClientWorker (line 20) | pub(crate) struct GlobalClientWorker<P: ProtocolClient> {
  type GlobalClientWorkerState (line 28) | struct GlobalClientWorkerState {
    method new (line 33) | fn new() -> Self {
  type ClientRequest (line 41) | pub(crate) struct ClientRequest {
    method new (line 47) | pub(crate) fn new(request: RemoteRequest, callback: Sender<RemoteRespo...
  function new (line 54) | pub(crate) fn new(
  function start (line 79) | async fn start(
  function init_connection (line 113) | async fn init_connection(
  function connect_with_retry (line 144) | async fn connect_with_retry(
  function close_connection (line 181) | pub(crate) async fn close_connection(&mut self) -> Result<(), GlobalColl...
  function response_loader (line 201) | async fn response_loader(
  function request_sender (line 246) | async fn request_sender(
  function request (line 290) | pub(crate) async fn request(&self, req: RemoteRequest) -> RemoteResponse {

FILE: crates/burn-collective/src/global/orchestrator/base.rs
  type GlobalOrchestrator (line 15) | pub(crate) struct GlobalOrchestrator {
    method start (line 21) | pub(crate) async fn start<F, S: ProtocolServer + Debug>(
    method handle_socket_response (line 57) | async fn handle_socket_response<S: ProtocolServer>(
    method handle_socket_request (line 94) | async fn handle_socket_request<S: ProtocolServer>(
  function start_global_orchestrator (line 132) | pub async fn start_global_orchestrator(port: u16) {

FILE: crates/burn-collective/src/global/orchestrator/state.rs
  type Session (line 15) | pub(crate) struct Session {
    method new (line 21) | fn new() -> Self {
    method respond (line 29) | async fn respond(&mut self, response: CollectiveMessageResponse) {
  type GlobalCollectiveState (line 34) | pub(crate) struct GlobalCollectiveState {
    method new (line 53) | pub fn new() -> Self {
    method init_session (line 65) | pub(crate) fn init_session(&mut self, id: SessionId) {
    method get_session_responder (line 73) | pub(crate) fn get_session_responder(
    method respond (line 84) | pub(crate) async fn respond(
    method process_request (line 94) | pub(crate) async fn process_request(
    method finish (line 125) | async fn finish(
    method register (line 167) | async fn register(

FILE: crates/burn-collective/src/global/shared.rs
  type RequestId (line 10) | pub(crate) struct RequestId(u32);
    method new (line 14) | pub(crate) fn new() -> Self {
  method default (line 21) | fn default() -> Self {
  type SessionId (line 28) | pub(crate) struct SessionId {
    method new (line 34) | pub(crate) fn new() -> Self {
  type CollectiveMessage (line 43) | pub(crate) enum CollectiveMessage {
  type CollectiveMessageResponse (line 50) | pub(crate) struct CollectiveMessageResponse {
  type RemoteRequest (line 57) | pub(crate) enum RemoteRequest {
  type RemoteResponse (line 74) | pub(crate) enum RemoteResponse {
  type GlobalCollectiveError (line 94) | pub enum GlobalCollectiveError {
    method from (line 129) | fn from(err: E) -> Self {

FILE: crates/burn-collective/src/local/all_reduce/base.rs
  function all_reduce_local_only (line 21) | pub(crate) async fn all_reduce_local_only<B: Backend>(
  function all_reduce_with_global (line 63) | pub(crate) async fn all_reduce_with_global<B: Backend, P: Protocol>(

FILE: crates/burn-collective/src/local/all_reduce/centralized.rs
  function all_reduce_sum_centralized (line 14) | pub(crate) fn all_reduce_sum_centralized<B: Backend>(

FILE: crates/burn-collective/src/local/all_reduce/op.rs
  type AllReduceOp (line 12) | pub struct AllReduceOp<B: Backend> {
  type AllReduceOpCall (line 23) | pub struct AllReduceOpCall<B: Backend> {
  type AllReduceResult (line 33) | pub(crate) type AllReduceResult<T> = Result<T, CollectiveError>;
  function new (line 36) | pub fn new(shape: Shape, reduce_op: ReduceOperation) -> Self {
  function peers (line 45) | fn peers(&self) -> Vec<PeerId> {
  function register_call (line 54) | pub fn register_call(
  function execute (line 88) | pub async fn execute<P: Protocol>(
  function all_reduce (line 117) | async fn all_reduce<P: Protocol>(
  function fail (line 136) | pub fn fail(self, err: CollectiveError) {

FILE: crates/burn-collective/src/local/all_reduce/ring.rs
  function all_reduce_sum_ring (line 13) | pub(crate) fn all_reduce_sum_ring<B: Backend>(
  function get_slice_dim (line 77) | pub(crate) fn get_slice_dim(shape: &Shape) -> usize {
  function ring_cycles (line 90) | fn ring_cycles<B: Backend>(
  function slice_tensors (line 138) | fn slice_tensors<B: Backend>(
  function get_ring_reduce_slice_ranges (line 177) | pub(crate) fn get_ring_reduce_slice_ranges(

FILE: crates/burn-collective/src/local/all_reduce/tree.rs
  function all_reduce_sum_tree (line 14) | pub(crate) fn all_reduce_sum_tree<B: Backend>(
  function all_reduce_sum_tree_inner (line 41) | fn all_reduce_sum_tree_inner<B: Backend>(

FILE: crates/burn-collective/src/local/broadcast/centralized.rs
  function broadcast_centralized (line 12) | pub(crate) fn broadcast_centralized<B: Backend>(

FILE: crates/burn-collective/src/local/broadcast/op.rs
  type BroadcastOp (line 14) | pub struct BroadcastOp<B: Backend> {
  type BroadcastOpCall (line 26) | pub struct BroadcastOpCall<B: Backend> {
  type BroadcastResult (line 36) | pub(crate) type BroadcastResult<T> = Result<T, CollectiveError>;
  function new (line 39) | pub fn new() -> Self {
  function effective_root (line 49) | pub fn effective_root(&self) -> PeerId {
  function peers (line 53) | pub fn peers(&self) -> Vec<PeerId> {
  function peer_devices (line 57) | fn peer_devices(&self) -> PeerDeviceMap<B> {
  function register_call (line 66) | pub fn register_call(
  function execute (line 100) | pub async fn execute<P: Protocol>(
  function broadcast (line 128) | async fn broadcast<P: Protocol>(
  function fail (line 167) | pub fn fail(self, err: CollectiveError) {

FILE: crates/burn-collective/src/local/broadcast/tree.rs
  function broadcast_tree (line 14) | pub(crate) fn broadcast_tree<B: Backend>(
  function broadcast_tree_inner (line 53) | fn broadcast_tree_inner<B: Backend>(

FILE: crates/burn-collective/src/local/client.rs
  type LocalCollectiveClient (line 14) | pub(crate) struct LocalCollectiveClient<B: Backend> {
  type PendingCollectiveOperation (line 19) | pub(crate) struct PendingCollectiveOperation<T> {
  function from (line 24) | fn from(value: PendingCollectiveOperation<T>) -> Self {
  function wait (line 35) | pub(crate) fn wait(self) -> Result<T, CollectiveError> {
  function start_operation (line 52) | pub(crate) fn start_operation<T, F>(&self, builder: F) -> PendingCollect...
  function start_valid_operation (line 66) | pub(crate) fn start_valid_operation<T, F>(
  function reset (line 84) | pub(crate) fn reset(&self) {
  function register (line 88) | pub(crate) fn register(
  function register_start (line 97) | pub(crate) fn register_start(
  function all_reduce (line 132) | pub fn all_reduce(
  function all_reduce_start (line 157) | pub(crate) fn all_reduce_start(
  function reduce (line 180) | pub fn reduce(
  function reduce_start (line 205) | pub(crate) fn reduce_start(
  function broadcast (line 230) | pub fn broadcast(
  function broadcast_start (line 252) | pub(crate) fn broadcast_start(
  function finish (line 264) | pub(crate) fn finish(&self, id: PeerId) -> FinishResult {
  function finish_start (line 268) | pub(crate) fn finish_start(&self, id: PeerId) -> PendingCollectiveOperat...

FILE: crates/burn-collective/src/local/reduce/centralized.rs
  function reduce_sum_centralized (line 15) | pub(crate) fn reduce_sum_centralized<B: Backend>(

FILE: crates/burn-collective/src/local/reduce/op.rs
  type ReduceOp (line 12) | pub struct ReduceOp<B: Backend> {
  type ReduceOpCall (line 24) | pub struct ReduceOpCall<B: Backend> {
  type ReduceResult (line 34) | pub(crate) type ReduceResult<T> = Result<Option<T>, CollectiveError>;
  function new (line 37) | pub fn new(shape: Shape, reduce_op: ReduceOperation, root: PeerId) -> Se...
  function peers (line 46) | fn peers(&self) -> Vec<PeerId> {
  function register_call (line 52) | pub fn register_call(
  function execute (line 90) | pub async fn execute<P: Protocol>(
  function reduce (line 118) | async fn reduce<P: Protocol>(
  function fail (line 158) | pub fn fail(self, err: CollectiveError) {

FILE: crates/burn-collective/src/local/reduce/tree.rs
  function reduce_sum_tree (line 10) | pub(crate) fn reduce_sum_tree<B: Backend>(
  function reduce_sum_tree_inner (line 43) | fn reduce_sum_tree_inner<B: Backend>(

FILE: crates/burn-collective/src/local/server.rs
  type Network (line 24) | type Network = WebSocket;
  type RegisterResult (line 26) | pub(crate) type RegisterResult = Result<(), CollectiveError>;
  type FinishResult (line 28) | pub(crate) type FinishResult = Result<(), CollectiveError>;
  type LocalCollectiveServer (line 35) | pub(crate) struct LocalCollectiveServer<B: Backend> {
  type Message (line 65) | pub(crate) enum Message<B: Backend> {
  type LocalClientBox (line 103) | type LocalClientBox = Box<dyn Any + Send + Sync>;
  function get_backend_client_map (line 109) | pub(crate) fn get_backend_client_map() -> MutexGuard<'static, HashMap<Ty...
  function get_collective_client (line 119) | pub(crate) fn get_collective_client<B: Backend>() -> LocalCollectiveClie...
  function get_collective_server_runtime (line 136) | pub(crate) fn get_collective_server_runtime() -> Arc<Runtime> {
  type LocalCollectiveClientConfig (line 149) | pub struct LocalCollectiveClientConfig {
    method from (line 163) | fn from(capacity: usize) -> Self {
  method default (line 155) | fn default() -> Self {
  function new (line 171) | fn new(rec: Receiver<Message<B>>) -> Self {
  function setup (line 186) | pub(crate) fn setup<C>(cfg: C) -> LocalCollectiveClient<B>
  function process_message (line 214) | async fn process_message(&mut self, message: Message<B>) {
  function process_register_message (line 257) | async fn process_register_message(
  function process_all_reduce_message (line 324) | async fn process_all_reduce_message(
  function process_reduce_message (line 366) | async fn process_reduce_message(
  function process_broadcast_message (line 414) | async fn process_broadcast_message(
  function reset (line 462) | fn reset(&mut self) {
  function process_finish_message (line 470) | async fn process_finish_message(&mut self, id: PeerId, callback: SyncSen...

FILE: crates/burn-collective/src/local/tensor_map.rs
  type CollectiveTensorMap (line 8) | pub type CollectiveTensorMap<B> = HashMap<PeerId, <B as Backend>::FloatT...
  type PeerDeviceMap (line 10) | pub type PeerDeviceMap<B> = HashMap<PeerId, <B as Backend>::Device>;
  function get_common_shape (line 13) | pub fn get_common_shape<B: Backend>(tensors: &CollectiveTensorMap<B>) ->...
  function get_peer_devices (line 28) | pub fn get_peer_devices<B: Backend>(tensors: &CollectiveTensorMap<B>) ->...

FILE: crates/burn-collective/src/tests/all_reduce.rs
  type TestBackend (line 10) | pub type TestBackend = burn_ndarray::NdArray<f32>;
  type TestBackend (line 13) | pub type TestBackend = burn_cuda::Cuda<f32>;
  type TestBackend (line 16) | pub type TestBackend = burn_wgpu::Wgpu<f32>;
  type TestBackend (line 19) | pub type TestBackend = burn_wgpu::Wgpu<f32>;
  type TestBackend (line 22) | pub type TestBackend = burn_wgpu::Wgpu<f32>;
  function run_peer (line 29) | pub fn run_peer<B: Backend>(
  function generate_random_input (line 49) | fn generate_random_input(
  function test_all_reduce (line 80) | fn test_all_reduce<B: Backend>(
  function test_all_reduce_centralized_sum (line 122) | pub fn test_all_reduce_centralized_sum() {
  function test_all_reduce_centralized_mean (line 128) | pub fn test_all_reduce_centralized_mean() {
  function test_all_reduce_binary_tree_sum (line 134) | pub fn test_all_reduce_binary_tree_sum() {
  function test_all_reduce_binary_tree_mean (line 140) | pub fn test_all_reduce_binary_tree_mean() {
  function test_all_reduce_5_tree_sum (line 146) | pub fn test_all_reduce_5_tree_sum() {
  function test_all_reduce_5_tree_mean (line 152) | pub fn test_all_reduce_5_tree_mean() {
  function test_all_reduce_ring_sum (line 158) | pub fn test_all_reduce_ring_sum() {
  function test_all_reduce_ring_mean (line 164) | pub fn test_all_reduce_ring_mean() {
  function test_all_reduce_ring_irregular_sum (line 170) | pub fn test_all_reduce_ring_irregular_sum() {

FILE: crates/burn-collective/src/tests/broadcast.rs
  type TestBackend (line 10) | pub type TestBackend = burn_ndarray::NdArray<f32>;
  type TestBackend (line 13) | pub type TestBackend = burn_cuda::Cuda<f32>;
  type TestBackend (line 16) | pub type TestBackend = burn_wgpu::Wgpu<f32>;
  type TestBackend (line 19) | pub type TestBackend = burn_wgpu::Wgpu<f32>;
  type TestBackend (line 22) | pub type TestBackend = burn_wgpu::Wgpu<f32>;
  function run_peer (line 28) | pub fn run_peer<B: Backend>(
  function generate_random_input (line 45) | fn generate_random_input(shape: Shape) -> TensorData {
  function test_broadcast (line 53) | fn test_broadcast<B: Backend>(
  function test_broadcast_centralized_sum (line 93) | pub fn test_broadcast_centralized_sum() {
  function test_broadcast_centralized_mean (line 99) | pub fn test_broadcast_centralized_mean() {
  function test_broadcast_binary_tree_sum (line 105) | pub fn test_broadcast_binary_tree_sum() {
  function test_broadcast_binary_tree_mean (line 111) | pub fn test_broadcast_binary_tree_mean() {
  function test_broadcast_5_tree_sum (line 117) | pub fn test_broadcast_5_tree_sum() {
  function test_broadcast_5_tree_mean (line 123) | pub fn test_broadcast_5_tree_mean() {

FILE: crates/burn-collective/src/tests/reduce.rs
  type TestBackend (line 10) | pub type TestBackend = burn_ndarray::NdArray<f32>;
  type TestBackend (line 13) | pub type TestBackend = burn_cuda::Cuda<f32>;
  type TestBackend (line 16) | pub type TestBackend = burn_wgpu::Wgpu<f32>;
  type TestBackend (line 19) | pub type TestBackend = burn_wgpu::Wgpu<f32>;
  type TestBackend (line 22) | pub type TestBackend = burn_wgpu::Wgpu<f32>;
  function run_peer (line 29) | pub fn run_peer<B: Backend>(
  function generate_random_input (line 50) | fn generate_random_input(
  function test_reduce (line 81) | fn test_reduce<B: Backend>(
  function test_reduce_centralized_sum (line 129) | pub fn test_reduce_centralized_sum() {
  function test_reduce_centralized_mean (line 135) | pub fn test_reduce_centralized_mean() {
  function test_reduce_binary_tree_sum (line 141) | pub fn test_reduce_binary_tree_sum() {
  function test_reduce_binary_tree_mean (line 147) | pub fn test_reduce_binary_tree_mean() {
  function test_reduce_5_tree_sum (line 153) | pub fn test_reduce_5_tree_sum() {
  function test_reduce_5_tree_mean (line 159) | pub fn test_reduce_5_tree_mean() {

FILE: crates/burn-communication/src/base.rs
  type Address (line 9) | pub struct Address {
  type Err (line 14) | type Err = String;
  method from_str (line 16) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method fmt (line 24) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Protocol (line 30) | pub trait Protocol: Clone + Send + Sync + 'static {
  type CommunicationError (line 38) | pub trait CommunicationError: Debug + Send + 'static {}
  type ProtocolClient (line 42) | pub trait ProtocolClient: Send + Sync + 'static {
    method connect (line 55) | fn connect(address: Address, route: &str) -> DynFut<Option<Self::Chann...
  type Message (line 60) | pub struct Message {
  type ProtocolServer (line 66) | pub trait ProtocolServer: Sized + Send + Sync + 'static {
    method route (line 74) | fn route<C, Fut>(self, path: &str, callback: C) -> Self
    method serve (line 80) | fn serve<F>(
  type CommunicationChannel (line 89) | pub trait CommunicationChannel: Send + 'static {
    method send (line 93) | fn send(
    method recv (line 99) | fn recv(
    method close (line 103) | fn close(&mut self) -> impl std::future::Future<Output = Result<(), Se...

FILE: crates/burn-communication/src/data_service.rs
  type TensorTransferId (line 18) | pub struct TensorTransferId(u64);
    method from (line 21) | fn from(value: u64) -> Self {
    method next (line 27) | pub fn next(&mut self) {
  type DataServiceMessage (line 33) | enum DataServiceMessage {
  type ClientChannelRef (line 38) | type ClientChannelRef<C> = Arc<Mutex<<C as ProtocolClient>::Channel>>;
  type TensorDataService (line 40) | pub struct TensorDataService<B: Backend, P: Protocol<Client: ProtocolCli...
  type TensorExposeState (line 53) | pub struct TensorExposeState {
  type TensorDataServer (line 63) | pub trait TensorDataServer<B: Backend, P: Protocol> {
    method route_tensor_data_service (line 65) | fn route_tensor_data_service(self, state: Arc<TensorDataService<B, P>>...
  method route_tensor_data_service (line 71) | fn route_tensor_data_service(self, state: Arc<TensorDataService<B, P>>) ...
  function new (line 79) | pub fn new(cancel_token: CancellationToken) -> Self {
  function expose (line 90) | pub async fn expose(
  function expose_data (line 101) | pub async fn expose_data(
  function close (line 123) | pub async fn close(&self) {
  function download_tensor (line 140) | pub async fn download_tensor(
  function get_data_stream (line 178) | async fn get_data_stream(
  function get_exposed_tensor_bytes (line 202) | async fn get_exposed_tensor_bytes(
  function handle_data_channel (line 228) | pub(crate) async fn handle_data_channel(

FILE: crates/burn-communication/src/util.rs
  function os_shutdown_signal (line 7) | pub async fn os_shutdown_signal() {
  function init_logging (line 31) | pub(crate) fn init_logging() {

FILE: crates/burn-communication/src/websocket/base.rs
  type WebSocket (line 9) | pub struct WebSocket {}
  type Client (line 12) | type Client = WsClient;
  type Server (line 13) | type Server = WsServer;
  function parse_ws_address (line 17) | pub(crate) fn parse_ws_address(mut address: Address) -> Result<Address, ...

FILE: crates/burn-communication/src/websocket/client.rs
  type WsClient (line 14) | pub struct WsClient;
  type Channel (line 17) | type Channel = WsClientChannel;
  type Error (line 18) | type Error = WsClientError;
  method connect (line 20) | fn connect(address: Address, route: &str) -> DynFut<Option<WsClientChann...
  function connect_ws (line 26) | async fn connect_ws(address: Address, route: String) -> Option<WsClientC...
  type WsClientChannel (line 47) | pub struct WsClientChannel {
  type Error (line 52) | type Error = WsClientError;
  method send (line 54) | async fn send(&mut self, msg: Message) -> Result<(), WsClientError> {
  method recv (line 62) | async fn recv(&mut self) -> Result<Option<Message>, WsClientError> {
  method close (line 74) | async fn close(&mut self) -> Result<(), WsClientError> {
  type WsClientError (line 91) | pub enum WsClientError {
    method from (line 100) | fn from(err: std::io::Error) -> Self {
    method from (line 106) | fn from(err: tungstenite::Error) -> Self {

FILE: crates/burn-communication/src/websocket/server.rs
  type WsServer (line 18) | pub struct WsServer {
    method new (line 28) | pub fn new(port: u16) -> Self {
  type WsServerChannel (line 23) | pub struct WsServerChannel {
  type Channel (line 37) | type Channel = WsServerChannel;
  type Error (line 38) | type Error = WsServerError;
  method serve (line 40) | async fn serve<F>(self, shutdown: F) -> Result<(), Self::Error>
  method route (line 62) | fn route<C, Fut>(mut self, path: &str, callback: C) -> Self
  type Error (line 87) | type Error = WsServerError;
  method send (line 89) | async fn send(&mut self, message: Message) -> Result<(), WsServerError> {
  method recv (line 95) | async fn recv(&mut self) -> Result<Option<Message>, WsServerError> {
  method close (line 107) | async fn close(&mut self) -> Result<(), WsServerError> {
  type WsServerError (line 122) | pub enum WsServerError {
    method from (line 132) | fn from(err: std::io::Error) -> Self {
    method from (line 138) | fn from(err: axum::Error) -> Self {

FILE: crates/burn-core/src/config.rs
  type ConfigError (line 7) | pub enum ConfigError {
    method fmt (line 16) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type Config (line 35) | pub trait Config: Debug + serde::Serialize + serde::de::DeserializeOwned {
    method save (line 46) | fn save<P: AsRef<std::path::Path>>(&self, file: P) -> std::io::Result<...
    method load (line 60) | fn load<P: AsRef<std::path::Path>>(file: P) -> Result<Self, ConfigErro...
    method load_binary (line 75) | fn load_binary(data: &[u8]) -> Result<Self, ConfigError> {
  function config_to_json (line 92) | pub fn config_to_json<C: Config>(config: &C) -> String {
  function config_from_str (line 96) | fn config_from_str<C: Config>(content: &str) -> Result<C, ConfigError> {

FILE: crates/burn-core/src/data/dataloader/base.rs
  type Progress (line 9) | pub struct Progress {
  type DataLoaderIterator (line 18) | pub trait DataLoaderIterator<O>: Iterator<Item = O> {
    method progress (line 20) | fn progress(&self) -> Progress;
  type DataLoader (line 24) | pub trait DataLoader<B: Backend, O>: Send + Sync {
    method iter (line 26) | fn iter<'a>(&'a self) -> Box<dyn DataLoaderIterator<O> + 'a>;
    method num_items (line 30) | fn num_items(&self) -> usize;
    method to_device (line 33) | fn to_device(&self, device: &B::Device) -> Arc<dyn DataLoader<B, O>>;
    method slice (line 48) | fn slice(&self, start: usize, end: usize) -> Arc<dyn DataLoader<B, O>>;

FILE: crates/burn-core/src/data/dataloader/batch.rs
  type BatchDataLoader (line 12) | pub struct BatchDataLoader<B: Backend, I, O> {
  method clone (line 21) | fn clone(&self) -> Self {
  function new (line 47) | pub fn new(
  type BatchDataloaderIterator (line 65) | struct BatchDataloaderIterator<B: Backend, I, O> {
  function iter (line 79) | fn iter<'a>(&'a self) -> Box<dyn DataLoaderIterator<O> + 'a> {
  function num_items (line 98) | fn num_items(&self) -> usize {
  function to_device (line 102) | fn to_device(&self, device: &B::Device) -> Arc<dyn DataLoader<B, O>> {
  function slice (line 116) | fn slice(&self, start: usize, end: usize) -> Arc<dyn DataLoader<B, O>> {
  function new (line 145) | pub fn new(
  type Item (line 162) | type Item = O;
  method next (line 164) | fn next(&mut self) -> Option<O> {
  function progress (line 183) | fn progress(&self) -> Progress {
  function test_batch_dataloader (line 198) | fn test_batch_dataloader() {
  function test_batch_dataloader_slice (line 226) | fn test_batch_dataloader_slice() {

FILE: crates/burn-core/src/data/dataloader/batcher.rs
  type Batcher (line 7) | pub trait Batcher<B: Backend, I, O>: Send + Sync {
    method batch (line 18) | fn batch(&self, items: Vec<I>, device: &B::Device) -> O;
  type TestBatcher (line 24) | pub struct TestBatcher;
    method batch (line 28) | fn batch(&self, items: Vec<I>, _device: &<TestBackend as Backend>::Dev...

FILE: crates/burn-core/src/data/dataloader/builder.rs
  type DataLoaderBuilder (line 11) | pub struct DataLoaderBuilder<B: Backend, I, O> {
  function new (line 34) | pub fn new<Bt>(batcher: Bt) -> Self
  function batch_size (line 58) | pub fn batch_size(mut self, batch_size: usize) -> Self {
  function shuffle (line 74) | pub fn shuffle(mut self, seed: u64) -> Self {
  function num_workers (line 94) | pub fn num_workers(mut self, num_workers: usize) -> Self {
  function set_device (line 108) | pub fn set_device(mut self, device: B::Device) -> Self {
  function build (line 122) | pub fn build<D>(self, dataset: D) -> Arc<dyn DataLoader<B, O>>
  type TestBatcherDevice (line 165) | struct TestBatcherDevice;
    method batch (line 169) | fn batch(&self, _items: Vec<I>, device: &TestDevice) -> TestDevice {
  type TestDevice (line 174) | type TestDevice = <TestBackend as Backend>::Device;
  function test_dataloader_no_workers (line 177) | fn test_dataloader_no_workers() {
  function test_dataloader_default_device (line 193) | fn test_dataloader_default_device() {
  function test_dataloader_slice_multi_device (line 208) | fn test_dataloader_slice_multi_device() {

FILE: crates/burn-core/src/data/dataloader/multithread.rs
  constant MAX_QUEUED_ITEMS (line 13) | const MAX_QUEUED_ITEMS: usize = 100;
  type RngSeed (line 15) | type RngSeed = <StdRng as SeedableRng>::Seed;
  type MultiThreadDataLoader (line 18) | pub struct MultiThreadDataLoader<B: Backend, I, O> {
  type Message (line 33) | pub enum Message<O> {
  type MultiThreadsDataloaderIterator (line 41) | struct MultiThreadsDataloaderIterator<O> {
  function new (line 68) | pub fn new(
  function from_seed (line 88) | fn from_seed(
  function initialize (line 108) | fn initialize(&self) -> &[BatchDataLoader<B, I, O>] {
  function iter (line 160) | fn iter<'a>(&'a self) -> Box<dyn DataLoaderIterator<O> + 'a> {
  function num_items (line 202) | fn num_items(&self) -> usize {
  function to_device (line 208) | fn to_device(&self, device: &B::Device) -> Arc<dyn DataLoader<B, O>> {
  function slice (line 219) | fn slice(&self, start: usize, end: usize) -> Arc<dyn DataLoader<B, O>> {
  function new (line 233) | pub fn new(
  function progress (line 247) | fn progress(&self) -> Progress {
  type Item (line 261) | type Item = O;
  method next (line 263) | fn next(&mut self) -> Option<O> {
  function test_multi_thread_batch_dataloader (line 304) | fn test_multi_thread_batch_dataloader() {
  function test_multi_thread_batch_dataloader_shuffle (line 342) | fn test_multi_thread_batch_dataloader_shuffle() {
  function test_multi_thread_batch_dataloader_incomplete_batches (line 407) | fn test_multi_thread_batch_dataloader_incomplete_batches() {

FILE: crates/burn-core/src/data/dataloader/split.rs
  function split_dataloader (line 8) | pub fn split_dataloader<B: Backend, O>(
  function test_split_batch_dataloader (line 46) | fn test_split_batch_dataloader() {

FILE: crates/burn-core/src/data/dataloader/strategy.rs
  type BatchStrategy (line 2) | pub trait BatchStrategy<I>: Send + Sync {
    method add (line 8) | fn add(&mut self, item: I);
    method batch (line 19) | fn batch(&mut self, force: bool) -> Option<Vec<I>>;
    method clone_dyn (line 26) | fn clone_dyn(&self) -> Box<dyn BatchStrategy<I>>;
    method batch_size (line 33) | fn batch_size(&self) -> Option<usize>;
  type FixBatchStrategy (line 37) | pub struct FixBatchStrategy<I> {
  function new (line 52) | pub fn new(batch_size: usize) -> Self {
  function add (line 61) | fn add(&mut self, item: I) {
  function batch (line 65) | fn batch(&mut self, force: bool) -> Option<Vec<I>> {
  function clone_dyn (line 80) | fn clone_dyn(&self) -> Box<dyn BatchStrategy<I>> {
  function batch_size (line 84) | fn batch_size(&self) -> Option<usize> {

FILE: crates/burn-core/src/lib.rs
  type TestBackend (line 46) | pub type TestBackend = burn_ndarray::NdArray<f32>;
  type TestBackend (line 50) | pub type TestBackend = burn_tch::LibTorch<f32>;
  type TestBackend (line 54) | pub type TestBackend = burn_wgpu::Wgpu;
  type TestBackend (line 58) | pub type TestBackend = burn_cuda::Cuda;
  type TestBackend (line 62) | pub type TestBackend = burn_rocm::Rocm;
  type TestAutodiffBackend (line 66) | pub type TestAutodiffBackend = burn_autodiff::Autodiff<TestBackend>;
  type SimpleLinear (line 83) | pub struct SimpleLinear<B: Backend> {
  function new (line 89) | pub fn new(in_features: usize, out_features: usize, device: &B::Device) ...

FILE: crates/burn-core/src/module/base.rs
  type Devices (line 12) | pub type Devices<B> = Vec<Device<B>>;
  type Module (line 84) | pub trait Module<B: Backend>: Clone + Send + core::fmt::Debug {
    method collect_devices (line 90) | fn collect_devices(&self, devices: Devices<B>) -> Devices<B>;
    method devices (line 93) | fn devices(&self) -> Devices<B> {
    method fork (line 103) | fn fork(self, device: &B::Device) -> Self;
    method to_device (line 113) | fn to_device(self, device: &B::Device) -> Self;
    method no_grad (line 122) | fn no_grad(self) -> Self {
    method train (line 136) | fn train<AB>(self) -> <Self as HasAutodiffModule<AB>>::TrainModule
    method num_params (line 145) | fn num_params(&self) -> usize {
    method visit (line 156) | fn visit<Visitor: ModuleVisitor<B>>(&self, visitor: &mut Visitor);
    method map (line 159) | fn map<Mapper: ModuleMapper<B>>(self, mapper: &mut Mapper) -> Self;
    method load_record (line 162) | fn load_record(self, record: Self::Record) -> Self;
    method into_record (line 165) | fn into_record(self) -> Self::Record;
    method save_file (line 184) | fn save_file<FR, PB>(
    method load_file (line 207) | fn load_file<FR, PB>(
    method quantize_weights (line 223) | fn quantize_weights(self, quantizer: &mut Quantizer) -> Self {
  type ModuleVisitor (line 229) | pub trait ModuleVisitor<B: Backend> {
    method visit_float (line 235) | fn visit_float<const D: usize>(&mut self, param: &Param<Tensor<B, D>>) {}
    method visit_int (line 242) | fn visit_int<const D: usize>(&mut self, param: &Param<Tensor<B, D, Int...
    method visit_bool (line 249) | fn visit_bool<const D: usize>(&mut self, param: &Param<Tensor<B, D, Bo...
    method enter_module (line 265) | fn enter_module(&mut self, name: &str, container_type: &str) {}
    method exit_module (line 281) | fn exit_module(&mut self, name: &str, container_type: &str) {}
    method visit_float_with_path (line 292) | fn visit_float_with_path<const D: usize>(
    method visit_int_with_path (line 309) | fn visit_int_with_path<const D: usize>(
    method visit_bool_with_path (line 326) | fn visit_bool_with_path<const D: usize>(
  type ModuleMapper (line 336) | pub trait ModuleMapper<B: Backend> {
    method enter_module (line 351) | fn enter_module(&mut self, name: &str, container_type: &str) {}
    method exit_module (line 367) | fn exit_module(&mut self, name: &str, container_type: &str) {}
    method map_float (line 377) | fn map_float<const D: usize>(&mut self, param: Param<Tensor<B, D>>) ->...
    method map_int (line 390) | fn map_int<const D: usize>(
    method map_bool (line 406) | fn map_bool<const D: usize>(
  type AutodiffModule (line 416) | pub trait AutodiffModule<B: AutodiffBackend>: Module<B> + Send + core::f...
    method valid (line 421) | fn valid(&self) -> Self::InnerModule;
    method from_inner (line 424) | fn from_inner(module: Self::InnerModule) -> Self;
  type HasAutodiffModule (line 428) | pub trait HasAutodiffModule<B: AutodiffBackend> {
  function test_module_val_train_stateful (line 441) | fn test_module_val_train_stateful() {

FILE: crates/burn-core/src/module/display.rs
  type ModuleDisplayDefault (line 11) | pub trait ModuleDisplayDefault {
    method content (line 21) | fn content(&self, _content: Content) -> Option<Content>;
    method num_params (line 24) | fn num_params(&self) -> usize {
    method content (line 529) | fn content(&self, content: Content) -> Option<Content> {
  type ModuleDisplay (line 34) | pub trait ModuleDisplay: ModuleDisplayDefault {
    method format (line 44) | fn format(&self, passed_settings: DisplaySettings) -> String {
    method custom_settings (line 130) | fn custom_settings(&self) -> Option<DisplaySettings> {
    method custom_content (line 143) | fn custom_content(&self, _content: Content) -> Option<Content> {
  type DisplaySettings (line 150) | pub struct DisplaySettings {
    method new (line 189) | pub fn new() -> Self {
    method with_show_param_id (line 202) | pub fn with_show_param_id(mut self, flag: bool) -> Self {
    method with_show_all_attributes (line 216) | pub fn with_show_all_attributes(mut self, flag: bool) -> Self {
    method with_show_num_parameters (line 230) | pub fn with_show_num_parameters(mut self, flag: bool) -> Self {
    method with_new_line_after_attribute (line 244) | pub fn with_new_line_after_attribute(mut self, flag: bool) -> Self {
    method with_indentation_size (line 258) | pub fn with_indentation_size(mut self, size: usize) -> Self {
    method inherit (line 272) | pub fn inherit(self, top: Self) -> Self {
    method optional (line 305) | pub fn optional(self) -> Option<Self> {
    method level_up (line 314) | pub fn level_up(mut self) -> Self {
    method show_param_id (line 326) | pub fn show_param_id(&self) -> bool {
    method show_all_attributes (line 337) | pub fn show_all_attributes(&self) -> bool {
    method show_num_parameters (line 348) | pub fn show_num_parameters(&self) -> bool {
    method new_line_after_attribute (line 359) | pub fn new_line_after_attribute(&self) -> bool {
    method indentation_size (line 370) | pub fn indentation_size(&self) -> usize {
  method default (line 171) | fn default() -> Self {
  type Content (line 377) | pub struct Content {
    method new (line 401) | pub fn new(display_settings: DisplaySettings) -> Self {
    method add (line 420) | pub fn add<T: ModuleDisplay + ?Sized>(mut self, name: &str, value: &T)...
    method add_debug_attribute (line 446) | pub fn add_debug_attribute<T: Debug>(mut self, name: &str, value: &T) ...
    method add_single (line 467) | pub fn add_single<T: ModuleDisplay + ?Sized>(mut self, value: &T) -> S...
    method add_formatted (line 486) | pub fn add_formatted<T: Display>(mut self, value: &T) -> Self {
    method optional (line 501) | pub fn optional(self) -> Option<Self> {
    method set_top_level_type (line 519) | pub fn set_top_level_type(mut self, ty: &str) -> Self {
  type DisplayAdapter (line 526) | struct DisplayAdapter<'a, T: Debug>(&'a T);
  type Attribute (line 538) | pub struct Attribute {
  function extract_type_name (line 554) | pub fn extract_type_name<T: ?Sized>() -> &'static str {

FILE: crates/burn-core/src/module/initializer.rs
  type Initializer (line 16) | pub enum Initializer {
    method init (line 87) | pub fn init<B: Backend, const D: usize, S: Into<Shape>>(
    method init_with (line 100) | pub fn init_with<B: Backend, const D: usize, S: Into<Shape>>(
    method init_tensor (line 131) | fn init_tensor<B: Backend, const D: usize, S: Into<Shape>>(
    method kaiming_std (line 198) | fn kaiming_std(
    method xavier_std (line 212) | fn xavier_std(&self, fan_in: Option<usize>, fan_out: Option<usize>) ->...
  function uniform_draw (line 225) | fn uniform_draw<B: Backend, const D: usize, S: Into<Shape>>(
  function normal_draw (line 235) | fn normal_draw<B: Backend, const D: usize, S: Into<Shape>>(
  function qr_decomposition (line 245) | fn qr_decomposition<B: Backend>(
  type TB (line 297) | pub type TB = burn_ndarray::NdArray<f32>;
  type FT (line 299) | type FT = FloatElem<TB>;
  function assert_normal_init (line 301) | fn assert_normal_init(expected_mean: f64, expected_var: f64, tensor: &Te...
  function initializer_uniform_init (line 324) | fn initializer_uniform_init() {
  function initializer_normal_init (line 338) | fn initializer_normal_init() {
  function initializer_constant_init (line 363) | fn initializer_constant_init() {
  function initializer_zeros_init (line 375) | fn initializer_zeros_init() {
  function initializer_ones_init (line 386) | fn initializer_ones_init() {
  function initializer_kaiming_uniform_init (line 396) | fn initializer_kaiming_uniform_init() {
  function initializer_kaiming_normal_init (line 414) | fn initializer_kaiming_normal_init() {
  function initializer_kaiming_uniform_init_bias (line 433) | fn initializer_kaiming_uniform_init_bias() {
  function initializer_kaiming_uniform_init_fan_out (line 452) | fn initializer_kaiming_uniform_init_fan_out() {
  function initializer_kaiming_uniform_no_fan (line 471) | fn initializer_kaiming_uniform_no_fan() {
  function initializer_xavier_uniform_init (line 487) | fn initializer_xavier_uniform_init() {
  function initializer_xavier_normal_init (line 507) | fn initializer_xavier_normal_init() {
  function initializer_xavier_uniform_no_fan (line 529) | fn initializer_xavier_uniform_no_fan() {
  function test_qr_decomposition (line 541) | fn test_qr_decomposition() {
  function initializer_orthogonal_correct (line 562) | fn initializer_orthogonal_correct() {
  function initializer_orthogonal_init (line 584) | fn initializer_orthogonal_init() {
  function initializer_orthogonal_init_1d (line 615) | fn initializer_orthogonal_init_1d() {

FILE: crates/burn-core/src/module/param/base.rs
  type Mapper (line 15) | type Mapper<T> = Arc<dyn Fn(T) -> T + Send + Sync>;
  type Mapper (line 18) | type Mapper<T> = Arc<Box<dyn Fn(T) -> T + Send + Sync>>;
  function new_mapper (line 21) | fn new_mapper<T, F: Fn(T) -> T + Send + Sync + 'static>(func: F) -> Mapp...
  function new_mapper (line 26) | fn new_mapper<T, F: Fn(T) -> T + Send + Sync + 'static>(func: F) -> Mapp...
  type Param (line 45) | pub struct Param<T: Parameter> {
  type ParamMapper (line 76) | pub struct ParamMapper<T: Parameter> {
  function fmt (line 82) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  function on_load (line 93) | pub fn on_load(&self, param: T) -> T {
  function on_save (line 100) | pub fn on_save(&self, param: T) -> T {
  method default (line 109) | fn default() -> Self {
  function fmt (line 118) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  function fmt (line 124) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type Parameter (line 130) | pub trait Parameter: Clone + core::fmt::Debug + Send {
    method device (line 135) | fn device(&self) -> Self::Device;
    method is_require_grad (line 138) | fn is_require_grad(&self) -> bool;
    method set_require_grad (line 141) | fn set_require_grad(self, require_grad: bool) -> Self;
  type Uninitialized (line 146) | pub(crate) struct Uninitialized<P: Parameter> {
  function initialize (line 166) | fn initialize(self) -> P {
  function initialized (line 174) | pub fn initialized(id: ParamId, value: T) -> Self {
  function uninitialized (line 186) | pub fn uninitialized<F>(
  function val (line 214) | pub fn val(&self) -> T {
  function is_initialized (line 233) | pub fn is_initialized(&self) -> bool {
  function into_value (line 238) | pub fn into_value(self) -> T {
  function consume (line 243) | pub fn consume(self) -> (ParamId, T, ParamMapper<T>) {
  function map (line 252) | pub fn map<F: FnOnce(T) -> T>(self, func: F) -> Self {
  function from_mapped_value (line 270) | pub fn from_mapped_value(id: ParamId, value: T, param_mapper: ParamMappe...
  function load_mapper (line 282) | pub fn load_mapper<F: Fn(T) -> T + Send + Sync + 'static>(mut self, func...
  function save_mapper (line 289) | pub fn save_mapper<F: Fn(T) -> T + Send + Sync + 'static>(mut self, func...
  function init_mapper (line 296) | pub fn init_mapper<F: FnOnce(T) -> T + Send + 'static>(self, func: F) ->...
  function lazy_device (line 336) | pub fn lazy_device(&self) -> T::Device {
  function lazy_is_require_grad (line 361) | pub(crate) fn lazy_is_require_grad(&self) -> bool {
  function set_require_grad (line 376) | pub fn set_require_grad(self, require_grad: bool) -> Self {
  method clone (line 401) | fn clone(&self) -> Self {
  type Target (line 409) | type Target = T;
  method deref (line 411) | fn deref(&self) -> &Self::Target {

FILE: crates/burn-core/src/module/param/constant.rs
  type ConstantRecord (line 23) | pub type ConstantRecord = EmptyRecord;
  type EmptyRecord (line 33) | pub struct EmptyRecord;
    method serialize (line 36) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    method deserialize (line 46) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    type Item (line 56) | type Item<S: PrecisionSettings> = EmptyRecord;
    method into_item (line 58) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {
    method from_item (line 62) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, _device: &B::D...
  function content (line 161) | fn content(&self, content: burn::module::Content) -> Option<burn::module...
  type Record (line 168) | type Record = EmptyRecord;
  function visit (line 170) | fn visit<V: ModuleVisitor<B>>(&self, _visitor: &mut V) {}
  function map (line 172) | fn map<M: ModuleMapper<B>>(self, _mapper: &mut M) -> Self {
  function into_record (line 176) | fn into_record(self) -> Self::Record {
  function load_record (line 180) | fn load_record(self, _record: Self::Record) -> Self {
  function to_device (line 184) | fn to_device(self, device: &B::Device) -> Self {
  function fork (line 188) | fn fork(self, device: &B::Device) -> Self {
  function collect_devices (line 192) | fn collect_devices(&self, mut devices: Devices<B>) -> Devices<B> {
  method content (line 204) | fn content(&self, content: Content) -> Option<Content> {
  type InnerModule (line 215) | type InnerModule = Tensor<B::InnerBackend, D, K::InnerKind>;
  function valid (line 217) | fn valid(&self) -> Self::InnerModule {
  function from_inner (line 221) | fn from_inner(tensor: Self::InnerModule) -> Self {
  type Record (line 227) | type Record = EmptyRecord;
  function visit (line 229) | fn visit<V: ModuleVisitor<B>>(&self, _visitor: &mut V) {
  function map (line 233) | fn map<M: ModuleMapper<B>>(self, _mapper: &mut M) -> Self {
  function load_record (line 237) | fn load_record(self, _record: Self::Record) -> Self {
  function into_record (line 241) | fn into_record(self) -> Self::Record {
  function to_device (line 245) | fn to_device(self, _: &Device<B>) -> Self {
  function fork (line 249) | fn fork(self, _: &Device<B>) -> Self {
  function collect_devices (line 253) | fn collect_devices(&self, devices: Devices<B>) -> Devices<B> {
  method content (line 259) | fn content(&self, content: Content) -> Option<Content> {
  type InnerModule (line 267) | type InnerModule = PhantomData<B::InnerBackend>;
  function valid (line 269) | fn valid(&self) -> Self::InnerModule {
  function from_inner (line 273) | fn from_inner(_module: Self::InnerModule) -> Self {
  type Ignored (line 284) | pub struct Ignored<T>(pub T);
  type Record (line 292) | type Record = EmptyRecord;
  function visit (line 294) | fn visit<V: ModuleVisitor<B>>(&self, _visitor: &mut V) {
  function map (line 298) | fn map<M: ModuleMapper<B>>(self, _mapper: &mut M) -> Self {
  function load_record (line 302) | fn load_record(self, _record: Self::Record) -> Self {
  function into_record (line 306) | fn into_record(self) -> Self::Record {
  function to_device (line 310) | fn to_device(self, _: &Device<B>) -> Self {
  function fork (line 314) | fn fork(self, _: &Device<B>) -> Self {
  function collect_devices (line 318) | fn collect_devices(&self, devices: Devices<B>) -> Devices<B> {
  method content (line 328) | fn content(&self, content: Content) -> Option<Content> {
  method fmt (line 342) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type InnerModule (line 353) | type InnerModule = Ignored<T>;
  function valid (line 355) | fn valid(&self) -> Self::InnerModule {
  function from_inner (line 359) | fn from_inner(module: Self::InnerModule) -> Self {
  type Target (line 367) | type Target = T;
  function deref (line 369) | fn deref(&self) -> &Self::Target {
  function tensor_load_record_setting (line 391) | fn tensor_load_record_setting() {
  function empty_module_with_phantom (line 424) | fn empty_module_with_phantom() {

FILE: crates/burn-core/src/module/param/id.rs
  type DefaultHashBuilder (line 10) | type DefaultHashBuilder = core::hash::BuildHasherDefault<ahash::AHasher>;
  type ParamId (line 14) | pub struct ParamId {
    method from (line 19) | fn from(value: u64) -> Self {
    method new (line 32) | pub fn new() -> Self {
    method val (line 39) | pub fn val(&self) -> u64 {
    method serialize (line 44) | pub fn serialize(self) -> String {
    method deserialize (line 51) | pub fn deserialize(encoded: &str) -> ParamId {
    method fmt (line 77) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  method default (line 25) | fn default() -> Self {
  function param_serde_deserialize (line 87) | fn param_serde_deserialize() {
  function param_serde_deserialize_legacy (line 94) | fn param_serde_deserialize_legacy() {
  function param_serde_deserialize_legacy_uuid (line 102) | fn param_serde_deserialize_legacy_uuid() {
  function param_serde_deserialize_invalid_id (line 112) | fn param_serde_deserialize_invalid_id() {

FILE: crates/burn-core/src/module/param/primitive.rs
  type Record (line 19) | type Record = Option<T::Record>;
  function visit (line 21) | fn visit<V: ModuleVisitor<B>>(&self, visitor: &mut V) {
  function map (line 27) | fn map<M: ModuleMapper<B>>(self, mapper: &mut M) -> Self {
  function load_record (line 31) | fn load_record(self, record: Self::Record) -> Self {
  function into_record (line 42) | fn into_record(self) -> Self::Record {
  function to_device (line 46) | fn to_device(self, device: &Device<B>) -> Self {
  function fork (line 50) | fn fork(self, device: &Device<B>) -> Self {
  function collect_devices (line 54) | fn collect_devices(&self, mut devices: Vec<B::Device>) -> Vec<B::Device> {
  method content (line 64) | fn content(&self, content: Content) -> Option<Content> {
  type InnerModule (line 79) | type InnerModule = Option<T::InnerModule>;
  function valid (line 81) | fn valid(&self) -> Self::InnerModule {
  function from_inner (line 85) | fn from_inner(module: Self::InnerModule) -> Self {
  type Record (line 95) | type Record = Vec<T::Record>;
  function num_params (line 97) | fn num_params(&self) -> usize {
  function visit (line 106) | fn visit<V: ModuleVisitor<B>>(&self, visitor: &mut V) {
  function map (line 115) | fn map<M: ModuleMapper<B>>(self, mapper: &mut M) -> Self {
  function into_record (line 128) | fn into_record(self) -> Self::Record {
  function load_record (line 132) | fn load_record(self, record: Self::Record) -> Self {
  function to_device (line 147) | fn to_device(self, device: &Device<B>) -> Self {
  function fork (line 153) | fn fork(self, device: &Device<B>) -> Self {
  function collect_devices (line 157) | fn collect_devices(&self, mut devices: Vec<B::Device>) -> Vec<B::Device> {
  method content (line 167) | fn content(&self, content: Content) -> Option<Content> {
  type InnerModule (line 186) | type InnerModule = Vec<T::InnerModule>;
  function valid (line 188) | fn valid(&self) -> Self::InnerModule {
  function from_inner (line 192) | fn from_inner(module: Self::InnerModule) -> Self {
  type Record (line 205) | type Record = [T::Record; N];
  function collect_devices (line 207) | fn collect_devices(&self, mut devices: Vec<B::Device>) -> Vec<B::Device> {
  function num_params (line 215) | fn num_params(&self) -> usize {
  function visit (line 224) | fn visit<V: ModuleVisitor<B>>(&self, visitor: &mut V) {
  function map (line 233) | fn map<M: ModuleMapper<B>>(self, mapper: &mut M) -> Self {
  function load_record (line 247) | fn load_record(self, record: Self::Record) -> Self {
  function into_record (line 256) | fn into_record(self) -> Self::Record {
  function to_device (line 260) | fn to_device(self, device: &Device<B>) -> Self {
  function fork (line 264) | fn fork(self, device: &Device<B>) -> Self {
  method content (line 270) | fn content(&self, content: Content) -> Option<Content> {
  type InnerModule (line 290) | type InnerModule = [T::InnerModule; N];
  function valid (line 292) | fn valid(&self) -> Self::InnerModule {
  function from_inner (line 296) | fn from_inner(module: Self::InnerModule) -> Self {
  function dont_override_constant_module_when_loading_record (line 409) | fn dont_override_constant_module_when_loading_record() {
  function dont_override_constant_module_when_loading_none_record (line 418) | fn dont_override_constant_module_when_loading_none_record() {

FILE: crates/burn-core/src/module/param/running.rs
  function get_thread_current_id (line 29) | pub(super) fn get_thread_current_id() -> ThreadId {
  function get_thread_current_id (line 40) | pub(super) fn get_thread_current_id() -> ThreadId {
  type RunningState (line 54) | pub struct RunningState<V> {
  function fmt (line 63) | fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
  method content (line 69) | fn content(&self, content: Content) -> Option<Content> {
  type Record (line 79) | type Record = Param<Tensor<B, D>>;
  function visit (line 81) | fn visit<V: ModuleVisitor<B>>(&self, visitor: &mut V) {
  function map (line 87) | fn map<M: ModuleMapper<B>>(self, mapper: &mut M) -> Self {
  function into_record (line 99) | fn into_record(self) -> Self::Record {
  function load_record (line 106) | fn load_record(mut self, record: Self::Record) -> Self {
  function to_device (line 116) | fn to_device(self, device: &Device<B>) -> Self {
  function fork (line 126) | fn fork(self, device: &Device<B>) -> Self {
  function collect_devices (line 130) | fn collect_devices(&self, mut devices: Vec<Device<B>>) -> Vec<Device<B>> {
  function new (line 143) | pub fn new(value: Tensor<B, D>) -> Self {
  function with_id (line 152) | pub fn with_id(id: ParamId, value: Tensor<B, D>) -> Self {
  function from_record (line 161) | pub fn from_record(record: Param<Tensor<B, D>>) -> Self {
  function update (line 171) | pub fn update(&self, value: Tensor<B, D>) {
  function value (line 187) | pub fn value(&self) -> Tensor<B, D> {
  function value_sync (line 198) | pub fn value_sync(&self) -> Tensor<B, D> {
  function sync (line 210) | fn sync(&self) {
  function update_value (line 218) | fn update_value(&self, map: &mut HashMap<ThreadId, Tensor<B, D>>) {
  type InnerModule (line 243) | type InnerModule = RunningState<Tensor<B::InnerBackend, D>>;
  function valid (line 245) | fn valid(&self) -> Self::InnerModule {
  function from_inner (line 252) | fn from_inner(module: Self::InnerModule) -> Self {

FILE: crates/burn-core/src/module/param/tensor.rs
  type Device (line 14) | type Device = B::Device;
  method device (line 16) | fn device(&self) -> Self::Device {
  method is_require_grad (line 20) | fn is_require_grad(&self) -> bool {
  method set_require_grad (line 24) | fn set_require_grad(self, require_grad: bool) -> Self {
  type Device (line 30) | type Device = B::Device;
  method device (line 32) | fn device(&self) -> Self::Device {
  method is_require_grad (line 36) | fn is_require_grad(&self) -> bool {
  method set_require_grad (line 40) | fn set_require_grad(self, _require_grad: bool) -> Self {
  type Device (line 46) | type Device = B::Device;
  method device (line 48) | fn device(&self) -> Self::Device {
  method is_require_grad (line 52) | fn is_require_grad(&self) -> bool {
  method set_require_grad (line 56) | fn set_require_grad(self, _require_grad: bool) -> Self {
  function from_tensor (line 69) | pub fn from_tensor(value: Tensor<B, D>) -> Self {
  function lazy_shape (line 83) | pub fn lazy_shape(&self) -> burn_tensor::Shape {
  function from_data (line 98) | pub fn from_data<T>(data: T, device: &B::Device) -> Self
  function transform_for_load (line 116) | pub fn transform_for_load(self, tensor: Tensor<B, D>, param_id: ParamId)...
  function transform_for_save (line 144) | pub fn transform_for_save(&self) -> Self {
  function lazy_shape (line 163) | pub fn lazy_shape(&self) -> burn_tensor::Shape {
  function transform_for_load (line 182) | pub fn transform_for_load(self, tensor: Tensor<B, D, Int>, param_id: Par...
  function transform_for_save (line 206) | pub fn transform_for_save(&self) -> Self {
  function lazy_shape (line 229) | pub fn lazy_shape(&self) -> burn_tensor::Shape {
  function transform_for_load (line 248) | pub fn transform_for_load(self, tensor: Tensor<B, D, Bool>, param_id: Pa...
  function transform_for_save (line 272) | pub fn transform_for_save(&self) -> Self {
  type Record (line 283) | type Record = Param<Tensor<B, D>>;
  function visit (line 285) | fn visit<V: ModuleVisitor<B>>(&self, visitor: &mut V) {
  function map (line 289) | fn map<M: ModuleMapper<B>>(self, mapper: &mut M) -> Self {
  function into_record (line 293) | fn into_record(self) -> Self::Record {
  function load_record (line 297) | fn load_record(self, record: Self::Record) -> Self {
  function to_device (line 302) | fn to_device(self, device: &Device<B>) -> Self {
  function fork (line 306) | fn fork(self, device: &Device<B>) -> Self {
  function collect_devices (line 319) | fn collect_devices(&self, mut devices: Vec<Device<B>>) -> Vec<Device<B>> {
  method content (line 331) | fn content(&self, content: Content) -> Option<Content> {
  type Record (line 347) | type Record = Param<Tensor<B, D, Int>>;
  function visit (line 349) | fn visit<V: ModuleVisitor<B>>(&self, visitor: &mut V) {
  function map (line 353) | fn map<M: ModuleMapper<B>>(self, mapper: &mut M) -> Self {
  function into_record (line 357) | fn into_record(self) -> Self::Record {
  function load_record (line 361) | fn load_record(self, record: Self::Record) -> Self {
  function to_device (line 366) | fn to_device(self, device: &Device<B>) -> Self {
  function fork (line 370) | fn fork(self, device: &Device<B>) -> Self {
  function collect_devices (line 374) | fn collect_devices(&self, mut devices: Vec<Device<B>>) -> Vec<Device<B>> {
  method content (line 386) | fn content(&self, content: Content) -> Option<Content> {
  type Record (line 402) | type Record = Param<Tensor<B, D, Bool>>;
  function visit (line 404) | fn visit<V: ModuleVisitor<B>>(&self, visitor: &mut V) {
  function map (line 408) | fn map<M: ModuleMapper<B>>(self, mapper: &mut M) -> Self {
  function into_record (line 412) | fn into_record(self) -> Self::Record {
  function load_record (line 416) | fn load_record(self, record: Self::Record) -> Self {
  function to_device (line 421) | fn to_device(self, device: &Device<B>) -> Self {
  function fork (line 425) | fn fork(self, device: &Device<B>) -> Self {
  function collect_devices (line 429) | fn collect_devices(&self, mut devices: Vec<Device<B>>) -> Vec<Device<B>> {
  method content (line 441) | fn content(&self, content: Content) -> Option<Content> {
  type InnerModule (line 459) | type InnerModule = Param<Tensor<B::InnerBackend, D>>;
  function valid (line 461) | fn valid(&self) -> Self::InnerModule {
  function from_inner (line 469) | fn from_inner(module: Self::InnerModule) -> Self {
  type TrainModule (line 479) | type TrainModule = Param<Tensor<B, D>>;
  type InnerModule (line 483) | type InnerModule = Param<Tensor<B::InnerBackend, D, Int>>;
  function valid (line 485) | fn valid(&self) -> Self::InnerModule {
  function from_inner (line 489) | fn from_inner(module: Self::InnerModule) -> Self {
  type InnerModule (line 495) | type InnerModule = Param<Tensor<B::InnerBackend, D, Bool>>;
  function valid (line 497) | fn valid(&self) -> Self::InnerModule {
  function from_inner (line 501) | fn from_inner(module: Self::InnerModule) -> Self {
  function test_load_record_setting (line 516) | fn test_load_record_setting() {
  function test_param_require_grad_stateful (line 542) | fn test_param_require_grad_stateful() {

FILE: crates/burn-core/src/module/param/visitor.rs
  type ParamIdCollector (line 7) | struct ParamIdCollector<'a, M> {
  function visit_float (line 17) | fn visit_float<const D: usize>(&mut self, param: &Param<Tensor<B, D>>) {
  function visit_int (line 20) | fn visit_int<const D: usize>(&mut self, param: &Param<Tensor<B, D, Int>>) {
  function visit_bool (line 23) | fn visit_bool<const D: usize>(&mut self, param: &Param<Tensor<B, D, Bool...
  function list_param_ids (line 29) | pub fn list_param_ids<M: Module<B>, B: Backend>(module: &M) -> Vec<Param...

FILE: crates/burn-core/src/module/quantize.rs
  type Quantizer (line 10) | pub struct Quantizer {
    method map_float (line 18) | fn map_float<const D: usize>(&mut self, param: Param<Tensor<B, D>>) ->...
  type B (line 40) | type B = TestBackend;
  function should_quantize_module (line 43) | fn should_quantize_module() {

FILE: crates/burn-core/src/module/reinit.rs
  type Reinitializer (line 13) | pub struct Reinitializer<B: Backend> {
  type ReinitStrategy (line 20) | enum ReinitStrategy<E> {
  method default (line 27) | fn default() -> Self {
  function new (line 34) | pub fn new() -> Self {
  function apply (line 46) | pub fn apply<M: Module<B>>(mut self, module: M) -> M {
  function constant (line 51) | pub fn constant(self, constant: f64) -> Self {
  function constant_float (line 56) | pub fn constant_float(mut self, constant: f64) -> Self {
  function constant_int (line 64) | pub fn constant_int(mut self, constant: i64) -> Self {
  function random (line 71) | pub fn random(self, seed: u64, min: f64, max: f64) -> Self {
  function random_float (line 77) | pub fn random_float(mut self, seed: u64, min: f64, max: f64) -> Self {
  function random_int (line 87) | pub fn random_int(mut self, seed: u64, min: i64, max: i64) -> Self {
  function range (line 97) | pub fn range(self, min: f64, max: f64) -> Self {
  function range_float (line 102) | pub fn range_float(mut self, min: f64, max: f64) -> Self {
  function range_int (line 111) | pub fn range_int(mut self, min: i64, max: i64) -> Self {
  function map_float (line 121) | fn map_float<const D: usize>(
  function map_int (line 151) | fn map_int<const D: usize>(
  function map_bool (line 179) | fn map_bool<const D: usize>(
  function resolve (line 188) | fn resolve<E: Element>(min: E, max: E, num_elements: usize) -> (E, E) {
  function random_vector (line 196) | fn random_vector<E: Element>(seed: u64, min: f64, max: f64, num_elements...

FILE: crates/burn-core/src/record/base.rs
  type Record (line 8) | pub trait Record<B: Backend>: Send {
    method into_item (line 13) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S>;
    method from_item (line 16) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, device: &B::De...

FILE: crates/burn-core/src/record/file.rs
  type FileRecorder (line 10) | pub trait FileRecorder<B: Backend>:
    method file_extension (line 14) | fn file_extension() -> &'static str;
  type DefaultFileRecorder (line 18) | pub type DefaultFileRecorder<S> = NamedMpkFileRecorder<S>;
  type BinFileRecorder (line 22) | pub struct BinFileRecorder<S: PrecisionSettings> {
  type BinGzFileRecorder (line 28) | pub struct BinGzFileRecorder<S: PrecisionSettings> {
  type JsonGzFileRecorder (line 34) | pub struct JsonGzFileRecorder<S: PrecisionSettings> {
  type PrettyJsonFileRecorder (line 40) | pub struct PrettyJsonFileRecorder<S: PrecisionSettings> {
  type NamedMpkGzFileRecorder (line 46) | pub struct NamedMpkGzFileRecorder<S: PrecisionSettings> {
  type NamedMpkFileRecorder (line 52) | pub struct NamedMpkFileRecorder<S: PrecisionSettings> {
  function file_extension (line 57) | fn file_extension() -> &'static str {
  function file_extension (line 62) | fn file_extension() -> &'static str {
  function file_extension (line 67) | fn file_extension() -> &'static str {
  function file_extension (line 72) | fn file_extension() -> &'static str {
  function file_extension (line 78) | fn file_extension() -> &'static str {
  function file_extension (line 84) | fn file_extension() -> &'static str {
  type Settings (line 134) | type Settings = S;
  type RecordArgs (line 135) | type RecordArgs = PathBuf;
  type RecordOutput (line 136) | type RecordOutput = ();
  type LoadArgs (line 137) | type LoadArgs = PathBuf;
  function save_item (line 139) | fn save_item<I: Serialize>(
  function load_item (line 154) | fn load_item<I: DeserializeOwned>(
  type Settings (line 168) | type Settings = S;
  type RecordArgs (line 169) | type RecordArgs = PathBuf;
  type RecordOutput (line 170) | type RecordOutput = ();
  type LoadArgs (line 171) | type LoadArgs = PathBuf;
  function save_item (line 173) | fn save_item<I: Serialize>(
  function load_item (line 185) | fn load_item<I: DeserializeOwned>(
  type Settings (line 197) | type Settings = S;
  type RecordArgs (line 198) | type RecordArgs = PathBuf;
  type RecordOutput (line 199) | type RecordOutput = ();
  type LoadArgs (line 200) | type LoadArgs = PathBuf;
  function save_item (line 202) | fn save_item<I: Serialize>(
  function load_item (line 215) | fn load_item<I: DeserializeOwned>(
  type Settings (line 229) | type Settings = S;
  type RecordArgs (line 230) | type RecordArgs = PathBuf;
  type RecordOutput (line 231) | type RecordOutput = ();
  type LoadArgs (line 232) | type LoadArgs = PathBuf;
  function save_item (line 234) | fn save_item<I: Serialize>(
  function load_item (line 245) | fn load_item<I: DeserializeOwned>(
  type Settings (line 258) | type Settings = S;
  type RecordArgs (line 259) | type RecordArgs = PathBuf;
  type RecordOutput (line 260) | type RecordOutput = ();
  type LoadArgs (line 261) | type LoadArgs = PathBuf;
  function save_item (line 263) | fn save_item<I: Serialize>(
  function load_item (line 276) | fn load_item<I: DeserializeOwned>(
  type Settings (line 290) | type Settings = S;
  type RecordArgs (line 291) | type RecordArgs = PathBuf;
  type RecordOutput (line 292) | type RecordOutput = ();
  type LoadArgs (line 293) | type LoadArgs = PathBuf;
  function save_item (line 295) | fn save_item<I: Serialize>(
  function load_item (line 308) | fn load_item<I: DeserializeOwned>(
  function file_path (line 337) | fn file_path(file: &str) -> PathBuf {
  function test_can_save_and_load_jsongz_format (line 342) | fn test_can_save_and_load_jsongz_format() {
  function test_can_save_and_load_bin_format (line 347) | fn test_can_save_and_load_bin_format() {
  function test_can_save_and_load_bingz_format (line 352) | fn test_can_save_and_load_bingz_format() {
  function test_can_save_and_load_pretty_json_format (line 357) | fn test_can_save_and_load_pretty_json_format() {
  function test_can_save_and_load_mpkgz_format (line 362) | fn test_can_save_and_load_mpkgz_format() {
  function test_can_save_and_load_mpk_format (line 367) | fn test_can_save_and_load_mpk_format() {
  function test_can_save_and_load (line 371) | fn test_can_save_and_load<Recorder>(recorder: Recorder)
  type PaddingConfig2d (line 410) | pub enum PaddingConfig2d {
  type Model (line 418) | pub struct Model<B: Backend> {
  function create_model (line 427) | pub fn create_model(device: &<TestBackend as Backend>::Device) -> Model<...

FILE: crates/burn-core/src/record/memory.rs
  type BytesRecorder (line 12) | pub trait BytesRecorder<
  type BinBytesRecorder (line 21) | pub struct BinBytesRecorder<
  type Settings (line 43) | type Settings = S;
  type RecordArgs (line 44) | type RecordArgs = ();
  type RecordOutput (line 45) | type RecordOutput = Vec<u8>;
  type LoadArgs (line 46) | type LoadArgs = L;
  function save_item (line 48) | fn save_item<I: Serialize>(
  function load_item (line 56) | fn load_item<I: DeserializeOwned>(
  type NamedMpkBytesRecorder (line 73) | pub struct NamedMpkBytesRecorder<S: PrecisionSettings> {
  type Settings (line 82) | type Settings = S;
  type RecordArgs (line 83) | type RecordArgs = ();
  type RecordOutput (line 84) | type RecordOutput = Vec<u8>;
  type LoadArgs (line 85) | type LoadArgs = Vec<u8>;
  function save_item (line 87) | fn save_item<I: Serialize>(
  function load_item (line 94) | fn load_item<I: DeserializeOwned>(
  function test_can_save_and_load_bin_format (line 111) | fn test_can_save_and_load_bin_format() {
  function test_can_save_and_load_named_mpk_format (line 117) | fn test_can_save_and_load_named_mpk_format() {
  function test_can_save_and_load (line 121) | fn test_can_save_and_load<Recorder>(recorder: Recorder)
  function create_model (line 138) | pub fn create_model<B: Backend>(device: &B::Device) -> SimpleLinear<B> {

FILE: crates/burn-core/src/record/primitive.rs
  type Item (line 21) | type Item<S: PrecisionSettings> = ();
  function into_item (line 23) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {}
  function from_item (line 25) | fn from_item<S: PrecisionSettings>(_item: Self::Item<S>, _device: &B::De...
  type Item (line 33) | type Item<S: PrecisionSettings> = Vec<T::Item<S>>;
  function into_item (line 35) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {
  function from_item (line 39) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, device: &B::Devi...
  type Item (line 51) | type Item<S: PrecisionSettings> = Option<T::Item<S>>;
  function into_item (line 53) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {
  function from_item (line 57) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, device: &B::Devi...
  type Item (line 72) | type Item<S: PrecisionSettings> = Array<N, T::Item<S>>;
  function into_item (line 74) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {
  function from_item (line 78) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, device: &B::Devi...
  type Item (line 125) | type Item<S: PrecisionSettings> = HashMap<String, T::Item<S>>;
  function into_item (line 127) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {
  function from_item (line 135) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, device: &B::Devi...
  type ParamSerde (line 146) | pub struct ParamSerde<T> {
  type Item (line 155) | type Item<S: PrecisionSettings> = ParamSerde<FloatTensorSerde<S>>;
  function into_item (line 157) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {
  function from_item (line 163) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, device: &B::Devi...
  type Item (line 178) | type Item<S: PrecisionSettings> = ParamSerde<IntTensorSerde<S>>;
  function into_item (line 180) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {
  function from_item (line 186) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, device: &B::Devi...
  type Item (line 200) | type Item<S: PrecisionSettings> = ParamSerde<BoolTensorSerde>;
  function into_item (line 202) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {
  function from_item (line 208) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, device: &B::Devi...
  type Array (line 268) | pub struct Array<const N: usize, T>([T; N]);
  method serialize (line 271) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  function deserialize (line 287) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

FILE: crates/burn-core/src/record/recorder.rs
  type Recorder (line 18) | pub trait Recorder<B: Backend>:
    method record (line 43) | fn record<R>(
    method load (line 58) | fn load<R>(&self, mut args: Self::LoadArgs, device: &B::Device) -> Res...
    method save_item (line 119) | fn save_item<I: Serialize>(
    method load_item (line 136) | fn load_item<I>(&self, args: &mut Self::LoadArgs) -> Result<I, Recorde...
  function recorder_metadata (line 141) | fn recorder_metadata<R, B>() -> BurnMetadata
  type RecorderError (line 157) | pub enum RecorderError {
    method fmt (line 169) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  function bin_config (line 176) | pub(crate) fn bin_config() -> bincode::config::Configuration {
  type BurnMetadata (line 182) | pub struct BurnMetadata {
  type BurnRecord (line 201) | pub struct BurnRecord<I, B: Backend> {
  function new (line 221) | pub fn new<R: Recorder<B>>(item: I) -> Self {
  type BurnRecordNoItem (line 234) | pub struct BurnRecordNoItem {
  type DefaultRecorder (line 243) | pub type DefaultRecorder = DefaultFileRecorder<FullPrecisionSettings>;
  type CompactRecorder (line 251) | pub type CompactRecorder = DefaultFileRecorder<HalfPrecisionSettings>;
  type SensitiveCompactRecorder (line 260) | pub type SensitiveCompactRecorder = BinGzFileRecorder<HalfPrecisionSetti...
  type NoStdTrainingRecorder (line 264) | pub type NoStdTrainingRecorder = BinFileRecorder<FullPrecisionSettings>;
  type NoStdInferenceRecorder (line 267) | pub type NoStdInferenceRecorder = BinBytesRecorder<FullPrecisionSettings...
  type DebugRecordSettings (line 274) | pub type DebugRecordSettings = PrettyJsonFileRecorder<FullPrecisionSetti...
  function err_when_invalid_item (line 287) | fn err_when_invalid_item() {

FILE: crates/burn-core/src/record/serde/adapter.rs
  type BurnModuleAdapter (line 6) | pub trait BurnModuleAdapter: Sized {
    method adapt (line 8) | fn adapt(name: &str, data: NestedValue) -> NestedValue {
    method adapt_linear (line 26) | fn adapt_linear(data: NestedValue) -> NestedValue {
    method adapt_conv1d (line 31) | fn adapt_conv1d(data: NestedValue) -> NestedValue {
    method adapt_conv2d (line 36) | fn adapt_conv2d(data: NestedValue) -> NestedValue {
    method adapt_conv3d (line 41) | fn adapt_conv3d(data: NestedValue) -> NestedValue {
    method adapt_conv_transpose_1d (line 46) | fn adapt_conv_transpose_1d(data: NestedValue) -> NestedValue {
    method adapt_conv_transpose_2d (line 51) | fn adapt_conv_transpose_2d(data: NestedValue) -> NestedValue {
    method adapt_conv_transpose_3d (line 56) | fn adapt_conv_transpose_3d(data: NestedValue) -> NestedValue {
    method adapt_embedding (line 61) | fn adapt_embedding(data: NestedValue) -> NestedValue {
    method adapt_group_norm (line 66) | fn adapt_group_norm(data: NestedValue) -> NestedValue {
    method adapt_layer_norm (line 71) | fn adapt_layer_norm(data: NestedValue) -> NestedValue {
    method adapt_batch_norm (line 76) | fn adapt_batch_norm(data: NestedValue) -> NestedValue {
  type DefaultAdapter (line 82) | pub struct DefaultAdapter;

FILE: crates/burn-core/src/record/serde/data.rs
  type NestedValue (line 20) | pub enum NestedValue {
    method as_map (line 77) | pub fn as_map(self) -> Option<HashMap<String, NestedValue>> {
    method as_bool (line 85) | pub fn as_bool(self) -> Option<bool> {
    method as_string (line 93) | pub fn as_string(self) -> Option<String> {
    method as_f32 (line 101) | pub fn as_f32(self) -> Option<f32> {
    method as_f64 (line 110) | pub fn as_f64(self) -> Option<f64> {
    method as_i16 (line 119) | pub fn as_i16(self) -> Option<i16> {
    method as_i32 (line 131) | pub fn as_i32(self) -> Option<i32> {
    method as_i64 (line 143) | pub fn as_i64(self) -> Option<i64> {
    method as_u8 (line 155) | pub fn as_u8(self) -> Option<u8> {
    method as_u16 (line 168) | pub fn as_u16(self) -> Option<u16> {
    method as_u64 (line 180) | pub fn as_u64(self) -> Option<u64> {
    method as_bytes (line 192) | pub fn as_bytes(self) -> Option<Bytes> {
    method try_into_record (line 201) | pub fn try_into_record<T, PS, A, B>(self, device: &B::Device) -> Resul...
    method fmt (line 371) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function remap (line 230) | pub fn remap<T>(
  function insert_nested_value (line 264) | fn insert_nested_value(current: &mut NestedValue, keys: &[&str], value: ...
  type Serializable (line 298) | pub trait Serializable {
    method serialize (line 314) | fn serialize<PS>(&self, serializer: Serializer) -> Result<NestedValue,...
  function unflatten (line 320) | pub fn unflatten<PS, T>(input: HashMap<String, T>) -> Result<NestedValue...
  function cleanup_empty_maps (line 343) | fn cleanup_empty_maps(current: &mut NestedValue) {
  function write_vec_truncated (line 356) | fn write_vec_truncated<T: core::fmt::Debug>(

FILE: crates/burn-core/src/record/serde/de.rs
  constant RECORD_ITEM_SUFFIX (line 13) | const RECORD_ITEM_SUFFIX: &str = "RecordItem";
  type Deserializer (line 16) | pub struct Deserializer<A: BurnModuleAdapter> {
  function new (line 31) | pub fn new(value: NestedValue, default_for_missing_fields: bool) -> Self {
  type Error (line 41) | type Error = Error;
  function deserialize_any (line 43) | fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_struct (line 50) | fn deserialize_struct<V>(
  function deserialize_string (line 102) | fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_ignored_any (line 109) | fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self...
  function deserialize_map (line 116) | fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_bool (line 133) | fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_i8 (line 140) | fn deserialize_i8<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_i16 (line 147) | fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_i32 (line 154) | fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_i64 (line 161) | fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_u8 (line 168) | fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_u16 (line 175) | fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_u32 (line 182) | fn deserialize_u32<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_u64 (line 189) | fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_f32 (line 196) | fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_f64 (line 203) | fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_char (line 210) | fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_str (line 217) | fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_bytes (line 224) | fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_byte_buf (line 231) | fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::E...
  function deserialize_option (line 242) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_unit (line 256) | fn deserialize_unit<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_unit_struct (line 263) | fn deserialize_unit_struct<V>(
  function deserialize_newtype_struct (line 274) | fn deserialize_newtype_struct<V>(
  function deserialize_seq (line 288) | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_tuple (line 317) | fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Val...
  function deserialize_tuple_struct (line 324) | fn deserialize_tuple_struct<V>(
  function deserialize_enum (line 357) | fn deserialize_enum<V>(
  function deserialize_identifier (line 397) | fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value, Self...
  type VecSeqAccess (line 406) | struct VecSeqAccess<A: BurnModuleAdapter, I> {
  function new (line 414) | fn new(vec: NestedValue, default_for_missing_fields: bool) -> Self {
  function new (line 428) | fn new(vec: NestedValue, default_for_missing_fields: bool) -> Self {
  function new (line 442) | fn new(vec: NestedValue, default_for_missing_fields: bool) -> Self {
  function new (line 456) | fn new(vec: NestedValue, default_for_missing_fields: bool) -> Self {
  type Error (line 474) | type Error = Error;
  function next_element_seed (line 476) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  type Error (line 498) | type Error = Error;
  function next_element_seed (line 500) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  type Error (line 523) | type Error = Error;
  function next_element_seed (line 525) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  type Error (line 548) | type Error = Error;
  function next_element_seed (line 550) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  type HashMapAccess (line 568) | struct HashMapAccess<A: BurnModuleAdapter> {
  function new (line 576) | fn new(map: HashMap<String, NestedValue>, default_for_missing_fields: bo...
  type Error (line 592) | type Error = Error;
  function next_key_seed (line 594) | fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self...
  function next_value_seed (line 609) | fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
  type ProbeEnumAccess (line 625) | struct ProbeEnumAccess<A: BurnModuleAdapter> {
  function new (line 633) | fn new(value: NestedValue, current_variant: String, default_for_missing_...
  type Error (line 647) | type Error = Error;
  type Variant (line 648) | type Variant = Self;
  function variant_seed (line 650) | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), S...
  type Error (line 663) | type Error = Error;
  function newtype_variant_seed (line 665) | fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
  function unit_variant (line 676) | fn unit_variant(self) -> Result<(), Self::Error> {
  function tuple_variant (line 697) | fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, ...
  function struct_variant (line 704) | fn struct_variant<V>(
  type NestedValueWrapper (line 719) | struct NestedValueWrapper<A: BurnModuleAdapter> {
  function new (line 726) | fn new(value: NestedValue, default_for_missing_fields: bool) -> Self {
  type Deserializer (line 736) | type Deserializer = Deserializer<A>;
  function into_deserializer (line 738) | fn into_deserializer(self) -> Self::Deserializer {
  type DefaultDeserializer (line 744) | struct DefaultDeserializer {
    method new (line 750) | fn new(originator_field_name: Option<String>) -> Self {
    type Error (line 758) | type Error = Error;
    method deserialize_any (line 760) | fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_i32 (line 767) | fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_f32 (line 774) | fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_i16 (line 781) | fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_i64 (line 788) | fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_u16 (line 795) | fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_u64 (line 802) | fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_f64 (line 809) | fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_bool (line 816) | fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_char (line 823) | fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_str (line 830) | fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_i8 (line 837) | fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_u8 (line 844) | fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_u32 (line 851) | fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_option (line 858) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::E...
    method deserialize_seq (line 865) | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_string (line 872) | fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::E...
    method deserialize_struct (line 879) | fn deserialize_struct<V>(
    method deserialize_tuple_struct (line 896) | fn deserialize_tuple_struct<V>(
    method deserialize_tuple (line 908) | fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Val...
    method deserialize_map (line 915) | fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  type DefaultSeqAccess (line 929) | pub struct DefaultSeqAccess {
    method new (line 941) | pub fn new(size: Option<usize>) -> Self {
    type Error (line 947) | type Error = Error;
    method next_element_seed (line 949) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>...
    method size_hint (line 963) | fn size_hint(&self) -> Option<usize> {
  method default (line 934) | fn default() -> Self {
  type DefaultMapAccess (line 969) | pub struct DefaultMapAccess;
    method new (line 979) | pub fn new() -> Self {
    type Error (line 985) | type Error = Error;
    method next_key_seed (line 987) | fn next_key_seed<T>(&mut self, _seed: T) -> Result<Option<T::Value>, S...
    method next_value_seed (line 995) | fn next_value_seed<T>(&mut self, _seed: T) -> Result<T::Value, Self::E...
    method size_hint (line 1002) | fn size_hint(&self) -> Option<usize> {
  method default (line 972) | fn default() -> Self {

FILE: crates/burn-core/src/record/serde/error.rs
  type Error (line 5) | pub enum Error {
    method custom (line 24) | fn custom<T: std::fmt::Display>(msg: T) -> Self {
    method custom (line 30) | fn custom<T: std::fmt::Display>(msg: T) -> Self {
  method from (line 37) | fn from(error: Error) -> Self {

FILE: crates/burn-core/src/record/serde/ser.rs
  type Serializer (line 19) | pub struct Serializer {
    method new (line 26) | pub fn new() -> Self {
  method default (line 32) | fn default() -> Self {
  type Ok (line 38) | type Ok = NestedValue;
  type Error (line 39) | type Error = Error;
  type SerializeSeq (line 40) | type SerializeSeq = Self;
  type SerializeTuple (line 41) | type SerializeTuple = ser::Impossible<NestedValue, Self::Error>;
  type SerializeTupleStruct (line 42) | type SerializeTupleStruct = ser::Impossible<NestedValue, Self::Error>;
  type SerializeTupleVariant (line 43) | type SerializeTupleVariant = ser::Impossible<NestedValue, Self::Error>;
  type SerializeMap (line 44) | type SerializeMap = ser::Impossible<NestedValue, Self::Error>;
  type SerializeStruct (line 45) | type SerializeStruct = Self;
  type SerializeStructVariant (line 46) | type SerializeStructVariant = ser::Impossible<NestedValue, Self::Error>;
  method serialize_struct (line 48) | fn serialize_struct(
  method serialize_newtype_struct (line 56) | fn serialize_newtype_struct<T>(
  method serialize_seq (line 67) | fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq...
  method serialize_i32 (line 71) | fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
  method serialize_str (line 75) | fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
  method serialize_i16 (line 79) | fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
  method serialize_i64 (line 83) | fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
  method serialize_u16 (line 87) | fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
  method serialize_u64 (line 91) | fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
  method serialize_f32 (line 95) | fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
  method serialize_f64 (line 99) | fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
  method serialize_char (line 106) | fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
  method serialize_bytes (line 110) | fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
  method serialize_none (line 114) | fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
  method serialize_u32 (line 117) | fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
  method serialize_bool (line 120) | fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
  method serialize_i8 (line 124) | fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
  method serialize_u8 (line 128) | fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
  method serialize_some (line 132) | fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
  method serialize_unit (line 139) | fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
  method serialize_unit_struct (line 143) | fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, ...
  method serialize_unit_variant (line 147) | fn serialize_unit_variant(
  method serialize_newtype_variant (line 159) | fn serialize_newtype_variant<T>(
  method serialize_tuple (line 172) | fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Se...
  method serialize_tuple_struct (line 176) | fn serialize_tuple_struct(
  method serialize_tuple_variant (line 184) | fn serialize_tuple_variant(
  method serialize_map (line 194) | fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap...
  method serialize_struct_variant (line 198) | fn serialize_struct_variant(
  type Ok (line 211) | type Ok = NestedValue;
  type Error (line 212) | type Error = Error;
  method serialize_field (line 214) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  method end (line 237) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type Ok (line 248) | type Ok = NestedValue;
  type Error (line 249) | type Error = Error;
  method serialize_element (line 251) | fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
  method end (line 299) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type MyStruct1 (line 322) | struct MyStruct1 {
  type MyStruct2 (line 328) | struct MyStruct2 {
  type MyStruct3 (line 336) | struct MyStruct3 {
  function test_serialize (line 342) | fn test_serialize() {
  function test_param_serde (line 368) | fn test_param_serde() {

FILE: crates/burn-core/src/record/settings.rs
  type PrecisionSettings (line 5) | pub trait PrecisionSettings:
    type FloatElem (line 28) | type FloatElem = f32;
    type IntElem (line 29) | type IntElem = i32;
    type FloatElem (line 33) | type FloatElem = f64;
    type IntElem (line 34) | type IntElem = i64;
    type FloatElem (line 38) | type FloatElem = half::f16;
    type IntElem (line 39) | type IntElem = i16;
  type FullPrecisionSettings (line 17) | pub struct FullPrecisionSettings;
  type HalfPrecisionSettings (line 21) | pub struct HalfPrecisionSettings;
  type DoublePrecisionSettings (line 25) | pub struct DoublePrecisionSettings;

FILE: crates/burn-core/src/record/tensor.rs
  function deserialize_data (line 10) | fn deserialize_data<'de, E, De>(deserializer: De) -> Result<TensorData, ...
  type FloatTensorSerde (line 31) | pub struct FloatTensorSerde<S: PrecisionSettings> {
  type IntTensorSerde (line 39) | pub struct IntTensorSerde<S: PrecisionSettings> {
  type BoolTensorSerde (line 46) | pub struct BoolTensorSerde {
    method deserialize (line 102) | fn deserialize<De>(deserializer: De) -> Result<Self, De::Error>
  method serialize (line 53) | fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error>
  function deserialize (line 62) | fn deserialize<De>(deserializer: De) -> Result<Self, De::Error>
  method serialize (line 73) | fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error>
  function deserialize (line 82) | fn deserialize<De>(deserializer: De) -> Result<Self, De::Error>
  method serialize (line 93) | fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error>
  type Item (line 115) | type Item<S: PrecisionSettings> = FloatTensorSerde<S>;
  function into_item (line 117) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {
  function from_item (line 127) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, device: &B::Devi...
  type Item (line 138) | type Item<S: PrecisionSettings> = IntTensorSerde<S>;
  function into_item (line 140) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {
  function from_item (line 144) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, device: &B::Devi...
  type Item (line 150) | type Item<S: PrecisionSettings> = BoolTensorSerde;
  function into_item (line 152) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {
  function from_item (line 156) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, device: &B::Devi...

FILE: crates/burn-core/tests/test_derive_config.rs
  type TestEmptyStructConfig (line 5) | pub struct TestEmptyStructConfig {}
  type TestStructConfig (line 8) | pub struct TestStructConfig {
  type TestEnumConfig (line 20) | pub enum TestEnumConfig {
  function file_path (line 29) | fn file_path(file_name: &str) -> std::path::PathBuf {
  function struct_config_should_impl_serde (line 35) | fn struct_config_should_impl_serde() {
  function struct_config_should_impl_clone (line 46) | fn struct_config_should_impl_clone() {
  function struct_config_should_impl_display (line 52) | fn struct_config_should_impl_display() {
  function enum_config_no_value_should_impl_serde (line 59) | fn enum_config_no_value_should_impl_serde() {
  function enum_config_one_value_should_impl_serde (line 71) | fn enum_config_one_value_should_impl_serde() {
  function enum_config_multiple_values_should_impl_serde (line 83) | fn enum_config_multiple_values_should_impl_serde() {
  function enum_config_should_impl_clone (line 94) | fn enum_config_should_impl_clone() {
  function enum_config_should_impl_display (line 100) | fn enum_config_should_impl_display() {
  function struct_config_can_load_binary (line 106) | fn struct_config_can_load_binary() {

FILE: crates/burn-core/tests/test_derive_module.rs
  type TestBackend (line 9) | pub type TestBackend = burn_ndarray::NdArray<f32>;
  type TestAutodiffBackend (line 11) | pub type TestAutodiffBackend = burn_autodiff::Autodiff<TestBackend>;
  type ModuleBasic (line 14) | pub struct ModuleBasic<B: Backend> {
  type ModuleTensorConstInt (line 20) | struct ModuleTensorConstInt<B: Backend> {
  function new (line 25) | fn new(device: &B::Device) -> Self {
  type ModuleWithConstGeneric (line 37) | struct ModuleWithConstGeneric<B: Backend, const N: usize> {
  type ModuleWithGenericModule (line 42) | struct ModuleWithGenericModule<B: Backend, M> {
  type ModuleEnum (line 49) | enum ModuleEnum<B: Backend> {
  type ModuleEnumNested (line 56) | enum ModuleEnumNested<B: Backend> {
  type ModuleEnumWithGenericModule (line 61) | enum ModuleEnumWithGenericModule<B: Backend, M: Module<B>> {
  type ModuleComposed (line 67) | pub struct ModuleComposed<B: Backend> {
  function new (line 74) | fn new(device: &B::Device) -> Self {
  type PaddingConfig (line 90) | pub enum PaddingConfig {
  type ModuleWithAttributes (line 96) | pub struct ModuleWithAttributes<B: Backend, M: Module<B>, N> {
  function new (line 116) | fn new(device: &B::Device) -> Self {
  type RecordItem (line 142) | type RecordItem<M, B, S> = <<M as Module<B>>::Record as Record<B>>::Item...
  function implements_clone (line 144) | fn implements_clone<T: Clone>() {}
  function basic_implements_clone (line 146) | fn basic_implements_clone<B: Backend, S: PrecisionSettings>() {
  function generic_implements_clone (line 151) | fn generic_implements_clone<B, S, M>()
  function should_load_from_record_basic (line 169) | fn should_load_from_record_basic() {
  function should_load_from_record_compose (line 189) | fn should_load_from_record_compose() {
  function should_load_from_record_enum (line 210) | fn should_load_from_record_enum() {
  function should_load_from_record_based_on_attributes (line 239) | fn should_load_from_record_based_on_attributes() {
  function should_load_from_record_const_generic (line 307) | fn should_load_from_record_const_generic() {
  function should_panic_load_from_incorrect_enum_variant (line 346) | fn should_panic_load_from_incorrect_enum_variant() {
  function should_calculate_num_params_basic (line 360) | fn should_calculate_num_params_basic() {
  function should_output_state_composed (line 367) | fn should_output_state_composed() {
  function should_calculate_num_params_enum (line 374) | fn should_calculate_num_params_enum() {
  function should_calculate_num_params_based_on_attributes (line 384) | fn should_calculate_num_params_based_on_attributes() {
  function should_have_grad_by_default (line 398) | fn should_have_grad_by_default() {
  function should_have_no_grad_after_no_grad (line 409) | fn should_have_no_grad_after_no_grad() {
  function should_have_grad_when_from_record (line 420) | fn should_have_grad_when_from_record() {
  function calculate_grads (line 434) | fn calculate_grads(

FILE: crates/burn-core/tests/test_derive_record.rs
  type TestWithBackendRecord (line 9) | pub struct TestWithBackendRecord<B: Backend> {
  type TestWithoutBackendRecord (line 15) | pub struct TestWithoutBackendRecord {

FILE: crates/burn-core/tests/test_record_resilience.rs
  type TestBackend (line 15) | type TestBackend = burn_ndarray::NdArray<f32>;
  type Linear (line 19) | pub struct Linear<B: Backend> {
  function new (line 25) | pub fn new(in_features: usize, out_features: usize, device: &B::Device) ...
  type Model (line 41) | pub struct Model<B: Backend> {
  type ModelNewOptionalField (line 50) | pub struct ModelNewOptionalField<B: Backend> {
  type ModelNewConstantField (line 60) | pub struct ModelNewConstantField<B: Backend> {
  type ModelNewFieldOrders (line 71) | pub struct ModelNewFieldOrders<B: Backend> {
  function deserialize_with_new_optional_field_works_with_default_file_recorder (line 80) | fn deserialize_with_new_optional_field_works_with_default_file_recorder() {
  function deserialize_with_removed_optional_field_works_with_default_file_recorder (line 89) | fn deserialize_with_removed_optional_field_works_with_default_file_recor...
  function deserialize_with_new_constant_field_works_with_default_file_recorder (line 98) | fn deserialize_with_new_constant_field_works_with_default_file_recorder() {
  function deserialize_with_removed_constant_field_works_with_default_file_recorder (line 107) | fn deserialize_with_removed_constant_field_works_with_default_file_recor...
  function deserialize_with_new_field_order_works_with_default_file_recorder (line 116) | fn deserialize_with_new_field_order_works_with_default_file_recorder() {
  function deserialize_with_new_optional_field_works_with_pretty_json (line 124) | fn deserialize_with_new_optional_field_works_with_pretty_json() {
  function deserialize_with_removed_optional_field_works_with_pretty_json (line 133) | fn deserialize_with_removed_optional_field_works_with_pretty_json() {
  function deserialize_with_new_constant_field_works_with_pretty_json (line 142) | fn deserialize_with_new_constant_field_works_with_pretty_json() {
  function deserialize_with_removed_constant_field_works_with_pretty_json (line 151) | fn deserialize_with_removed_constant_field_works_with_pretty_json() {
  function deserialize_with_new_field_order_works_with_pretty_json (line 160) | fn deserialize_with_new_field_order_works_with_pretty_json() {
  function deserialize_with_new_optional_field_works_with_bin_file_recorder (line 169) | fn deserialize_with_new_optional_field_works_with_bin_file_recorder() {
  function deserialize_with_removed_optional_field_works_with_bin_file_recorder (line 175) | fn deserialize_with_removed_optional_field_works_with_bin_file_recorder() {
  function deserialize_with_new_constant_field_works_with_bin_file_recorder (line 184) | fn deserialize_with_new_constant_field_works_with_bin_file_recorder() {
  function deserialize_with_removed_constant_field_works_with_bin_file_recorder (line 190) | fn deserialize_with_removed_constant_field_works_with_bin_file_recorder() {
  function deserialize_with_new_field_order_works_with_bin_file_recorder (line 199) | fn deserialize_with_new_field_order_works_with_bin_file_recorder() {
  function file_path (line 205) | fn file_path(filename: String) -> PathBuf {
  function test_tensor_serde (line 210) | fn test_tensor_serde() {
  function deserialize_with_new_optional_field (line 218) | fn deserialize_with_new_optional_field<R>(name: &str, recorder: R) -> Re...
  function deserialize_with_removed_optional_field (line 246) | fn deserialize_with_removed_optional_field<R>(
  function deserialize_with_new_constant_field (line 278) | fn deserialize_with_new_constant_field<R>(name: &str, recorder: R) -> Re...
  function deserialize_with_removed_constant_field (line 306) | fn deserialize_with_removed_constant_field<R>(
  function deserialize_with_new_field_order (line 338) | fn deserialize_with_new_field_order<R>(name: &str, recorder: R) -> Resul...

FILE: crates/burn-cpu/src/lib.rs
  type Cpu (line 10) | pub type Cpu<F = f32, I = i32> = CubeBackend<CpuRuntime, F, I, u8>;
  type Cpu (line 13) | pub type Cpu<F = f32, I = i32> = burn_fusion::Fusion<CubeBackend<CpuRunt...
  function should_support_dtypes (line 22) | fn should_support_dtypes() {

FILE: crates/burn-cubecl-fusion/src/base.rs
  type FallbackOperation (line 13) | pub trait FallbackOperation<R: Runtime>: Send + Sync {
    method run (line 15) | fn run(&self, context: &mut Context<'_, CubeFusionHandle<R>>);
  type QParams (line 20) | pub type QParams = burn_std::quantization::QParams<QParamTensor>;
  type CubeFusionHandle (line 23) | pub struct CubeFusionHandle<R: Runtime> {
  function fmt (line 39) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method clone (line 49) | fn clone(&self) -> Self {
  function binding (line 66) | pub fn binding(self, shape: Shape) -> TensorBinding<R> {
  function required_address_type (line 75) | pub fn required_address_type(&self) -> AddressType {
  function into_tensor_arg (line 86) | pub fn into_tensor_arg(self, shape: Shape) -> TensorArg<R> {
  function params (line 92) | pub fn params(&self, scheme: QuantScheme) -> Option<Self> {
  function strides_dyn_rank (line 114) | pub(crate) fn strides_dyn_rank(shape: &[usize]) -> Strides {

FILE: crates/burn-cubecl-fusion/src/engine/codegen/io.rs
  type Transform (line 18) | pub enum Transform {
  function read (line 40) | pub fn read<C: Scalar, N: Size>(
  function index_offset_with_quant_layout (line 163) | fn index_offset_with_quant_layout(
  function read_quantized (line 197) | pub fn read_quantized<C: Scalar, N: Size>(
  function read_scalar (line 221) | pub fn read_scalar<C: Scalar>(inputs: &GlobalArgs, #[comptime] arg: Fuse...
  function read_scalar_shape (line 233) | pub fn read_scalar_shape(inputs: &GlobalArgs, #[comptime] arg: FuseArg) ...
  function read_input (line 242) | pub fn read_input<C: Scalar, N: Size>(
  function read_input_window (line 263) | pub fn read_input_window<C: CubePrimitive>(
  function input_as_slice (line 277) | pub fn input_as_slice<C: CubePrimitive>(inputs: &GlobalArgs, #[comptime]...
  function input_as_scales_view (line 286) | pub fn input_as_scales_view<C: Scalar, N: Size>(
  function read_input_aligned (line 325) | pub fn read_input_aligned<C: Scalar, N: Size>(
  function get_offset_aligned (line 385) | pub fn get_offset_aligned(
  function read_output (line 412) | pub fn read_output<C: Scalar, N: Size>(
  function write (line 432) | pub fn write<C: Scalar, N: Size>(
  function write_scalar (line 469) | pub fn write_scalar<C: Scalar, N: Size>(
  function global_offset (line 494) | pub(crate) fn global_offset(
  function get_offset (line 517) | fn get_offset(
  function global_vector_size (line 539) | pub fn global_vector_size(
  function global_rank (line 549) | pub fn global_rank(global: &GlobalArgs, #[comptime] pos: usize) -> usize {
  function global_len (line 556) | pub fn global_len(global: &GlobalArgs, #[comptime] pos: usize) -> usize {
  function global_buffer_len (line 563) | pub fn global_buffer_len(global: &GlobalArgs, #[comptime] pos: usize) ->...
  function ref_len (line 570) | pub fn ref_len(
  function ref_buffer_len (line 588) | pub fn ref_buffer_len(
  function num_elements (line 613) | pub fn num_elements(locals: &LocalArgs, #[comptime] config: &FuseBlockCo...
  function ref_shape (line 625) | pub fn ref_shape(locals: &LocalArgs, axis: usize) -> usize {
  function ref_stride (line 631) | pub fn ref_stride(locals: &LocalArgs, axis: usize) -> usize {
  function ref_vector_size (line 637) | pub fn ref_vector_size(locals: &LocalArgs) -> comptime_type!(VectorSize) {
  function global_shape (line 643) | pub fn global_shape(global: &GlobalArgs, axis: usize, #[comptime] pos: u...
  function global_stride (line 650) | pub fn global_stride(global: &GlobalArgs, dim: usize, #[comptime] pos: u...
  function index_offset_with_layout (line 656) | fn index_offset_with_layout(
  function swap_dims_transform (line 714) | pub(crate) fn swap_dims_transform(i: usize, dims: (usize, usize)) -> usi...
  function reshaped_index (line 727) | fn reshaped_index(
  function reshaped_index_to_original_index (line 755) | fn reshaped_index_to_original_index<C: Scalar, N: Size>(
  function reverse_index (line 780) | pub(crate) fn reverse_index(
  function from_const_int (line 790) | fn from_const_int<C: CubePrimitive>(#[comptime] value: usize) -> C {
  function set_polyfill_typed (line 798) | pub(crate) fn set_polyfill_typed<C: CubePrimitive, Dyn: Scalar, DynSize:...

FILE: crates/burn-cubecl-fusion/src/engine/codegen/ir.rs
  type FuseArg (line 17) | pub enum FuseArg {
    method precision (line 81) | pub fn precision(&self) -> FuseType {
    method multi_block_variable (line 614) | pub fn multi_block_variable(&self, registers: &mut Vec<(MultiBlockPos,...
    method add_layout_info (line 766) | pub fn add_layout_info(&mut self, layout: LayoutInfo) {
  type MultiBlockPos (line 60) | pub struct MultiBlockPos {
  type LayoutInfo (line 71) | pub enum LayoutInfo {
  type ExpandType (line 98) | type ExpandType = Self;
  method into_mut (line 102) | fn into_mut(self, _context: &mut Scope) -> Self {
  method __expand_runtime_method (line 108) | fn __expand_runtime_method(self, _context: &mut Scope) -> Self::ExpandTy...
  type FuseOp (line 118) | pub enum FuseOp {
    method cmp_elem (line 258) | pub(crate) fn cmp_elem(&self) -> ElemType {
    method cmp_storage_ty (line 290) | pub(crate) fn cmp_storage_ty(&self) -> StorageType {
    method multi_block_variables (line 628) | pub fn multi_block_variables(&self, registers: &mut Vec<(MultiBlockPos...
  method fmt (line 174) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type QuantSchemeFuse (line 251) | pub struct QuantSchemeFuse {
  type GlobalArgs (line 297) | pub struct GlobalArgs {
  function required_address_type (line 312) | pub fn required_address_type(&self) -> AddressType {
  type MultiBlockVariables (line 324) | pub struct MultiBlockVariables {
    method init (line 335) | pub fn init(&mut self, #[comptime] key: MultiBlockPos) {
    method read (line 349) | pub fn read(&self, #[comptime] key: MultiBlockPos) -> Vector<DynElem, ...
    method write (line 360) | pub fn write(&mut self, #[comptime] key: MultiBlockPos, value: Vector<...
  type RuntimeArg (line 373) | type RuntimeArg<R: Runtime> = ();
  type CompilationArg (line 374) | type CompilationArg = ();
  method compilation_arg (line 376) | fn compilation_arg<R: Runtime>(_runtime_arg: &Self::RuntimeArg<R>) -> Se...
  method register (line 378) | fn register<R: Runtime>(_arg: Self::RuntimeArg<R>, _launcher: &mut Kerne...
  method expand (line 380) | fn expand(
  method default (line 391) | fn default() -> Self {
  function fmt (line 404) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function shape (line 415) | pub fn shape(&self, arg: &FuseArg) -> Shape {
  function shape_ref (line 423) | pub fn shape_ref(&self, ref_layout: &RefLayout, rank: usize) -> Shape {
  function strides (line 455) | pub fn strides(&self, arg: &FuseArg) -> Strides {
  function strides_ref (line 462) | pub fn strides_ref(&self, ref_layout: &RefLayout, rank: usize) -> Strides {
  function vector_size (line 486) | pub fn vector_size(&self, arg: &FuseArg) -> VectorSize {
  function resolve_arg (line 499) | pub fn resolve_arg(&self, arg: &FuseArg) -> &TensorArg<R> {
  type LocalArgs (line 511) | pub struct LocalArgs {
    method new (line 533) | pub fn new(
  type UnaryFuseArgs (line 560) | pub struct UnaryFuseArgs {
  type BinaryFuseArgs (line 567) | pub struct BinaryFuseArgs {
  type FuseType (line 580) | pub enum FuseType {
    method from (line 782) | fn from(value: ElemType) -> Self {
    method from (line 809) | fn from(value: StorageType) -> Self {
    method into_elem (line 816) | pub fn into_elem(self) -> ElemType {
    method into_storage_type (line 835) | pub fn into_storage_type(self) -> StorageType {
    method into_type (line 840) | pub fn into_type(self, vector_size: VectorSize) -> Type {
    method from (line 846) | fn from(value: DType) -> Self {
  type FuseBlockConfig (line 598) | pub struct FuseBlockConfig {
    method multi_block_variables (line 606) | pub fn multi_block_variables(&self, registers: &mut Vec<(MultiBlockPos...
  function multi_block_variables_init (line 717) | pub fn multi_block_variables_init(
  type RefLayout (line 739) | pub enum RefLayout {
  type VirtualLayout (line 747) | pub enum VirtualLayout {
  method fmt (line 889) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method fmt (line 906) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: crates/burn-cubecl-fusion/src/engine/codegen/kernel.rs
  function fuse_on_write (line 25) | pub fn fuse_on_write<E: Scalar, N: Size>(
  function fuse_on_read (line 63) | pub fn fuse_on_read<E: Scalar, N: Size>(
  function init_locals (line 95) | pub fn init_locals(
  function fuse (line 234) | fn fuse(
  function assign (line 402) | fn assign<C: Scalar, N: Size>(
  function gather (line 416) | fn gather<C: Numeric, N: Size>(
  function select_indices (line 545) | fn select_indices<C: Numeric, N: Size>(
  function conditional_assign (line 701) | fn conditional_assign<C: Scalar, N: Size>(
  function clamp (line 721) | fn clamp<C: Numeric, N: Size>(
  function dequantize (line 742) | fn dequantize<C: Float, N: Size>(

FILE: crates/burn-cubecl-fusion/src/engine/codegen/tensor.rs
  type GlobalTensor (line 14) | pub struct GlobalTensor {
  type GlobalTensorCompilationArg (line 28) | pub struct GlobalTensorCompilationArg {
  type GlobalTensorArg (line 35) | pub struct GlobalTensorArg<R: Runtime> {
  type RuntimeArg (line 43) | type RuntimeArg<R: Runtime> = GlobalTensorArg<R>;
  type CompilationArg (line 44) | type CompilationArg = GlobalTensorCompilationArg;
  method compilation_arg (line 46) | fn compilation_arg<R: Runtime>(runtime_arg: &Self::RuntimeArg<R>) -> Sel...
  method register (line 56) | fn register<R: Runtime>(arg: Self::RuntimeArg<R>, launcher: &mut KernelL...
  method expand (line 60) | fn expand(arg: &Self::CompilationArg, builder: &mut KernelBuilder) -> Gl...
  method expand_output (line 69) | fn expand_output(

FILE: crates/burn-cubecl-fusion/src/engine/codegen/view.rs
  type GlobalInput (line 24) | pub struct GlobalInput {
    method new (line 41) | pub fn new(
  method __expand_read_method (line 68) | fn __expand_read_method(
  method __expand_read_checked_method (line 77) | fn __expand_read_checked_method(
  method __expand_read_masked_method (line 87) | fn __expand_read_masked_method(
  method __expand_read_unchecked_method (line 104) | fn __expand_read_unchecked_method(
  method __expand_to_linear_slice_method (line 124) | fn __expand_to_linear_slice_method(
  method __expand_tensor_map_load_method (line 136) | fn __expand_tensor_map_load_method(
  method __expand_shape_method (line 147) | fn __expand_shape_method(&self, scope: &mut Scope) -> NativeExpand<usize> {
  method __expand_is_in_bounds_method (line 152) | fn __expand_is_in_bounds_method(
  method vector_size (line 164) | fn vector_size(&self) -> VectorSize {
  type FusedOutput (line 172) | pub struct FusedOutput {
    method new (line 183) | pub fn new(
  method __expand_read_method (line 203) | fn __expand_read_method(
  method __expand_read_checked_method (line 212) | fn __expand_read_checked_method(
  method __expand_read_masked_method (line 221) | fn __expand_read_masked_method(
  method __expand_read_unchecked_method (line 231) | fn __expand_read_unchecked_method(
  method __expand_to_linear_slice_method (line 240) | fn __expand_to_linear_slice_method(
  method __expand_tensor_map_load_method (line 250) | fn __expand_tensor_map_load_method(
  method __expand_shape_method (line 261) | fn __expand_shape_method(&self, scope: &mut Scope) -> NativeExpand<usize> {
  method __expand_is_in_bounds_method (line 272) | fn __expand_is_in_bounds_method(
  method __expand_write_method (line 291) | fn __expand_write_method(
  method __expand_write_checked_method (line 319) | fn __expand_write_checked_method(
  method __expand_to_linear_slice_mut_method (line 336) | fn __expand_to_linear_slice_mut_method(
  method __expand_tensor_map_store_method (line 346) | fn __expand_tensor_map_store_method(
  method vector_size (line 358) | fn vector_size(&self) -> VectorSize {

FILE: crates/burn-cubecl-fusion/src/engine/fuser.rs
  type TraceOperationFuser (line 29) | pub(crate) struct TraceOperationFuser {
    method can_fuse (line 42) | pub(crate) fn can_fuse(&self, op: &OperationIr) -> bool {
    method fuse (line 54) | fn fuse(&mut self, op: &OperationIr) {
    method finish (line 115) | fn finish(&mut self) -> FuseTrace {
    method len (line 119) | fn len(&self) -> usize {
    method reset (line 123) | fn reset(&mut self) {
    method status (line 132) | fn status(&self) -> FuserStatus {
    method properties (line 136) | fn properties(&self) -> FuserProperties {
    method clone_dyn (line 145) | fn clone_dyn(&self) -> Box<dyn OperationFuser<FuseTrace>> {
    method new (line 152) | pub fn new(max_bindings: u32, settings: FuseSettings) -> Self {
    method close (line 166) | pub fn close(&mut self) {
    method input_unhandled (line 175) | pub fn input_unhandled(&mut self, tensor: &TensorIr) -> FuseArg {
    method input_quantized_unhandled (line 187) | pub fn input_quantized_unhandled(&mut self, tensor: &TensorIr) -> Opti...
    method output_unhandled (line 201) | pub fn output_unhandled(&mut self, tensor: &TensorIr) -> FuseArg {
    method next_block (line 223) | pub fn next_block<const N: usize>(
    method block_local_input (line 244) | pub fn block_local_input(&mut self, tensor: &TensorIr, block_pos: usiz...
    method fuse_base (line 250) | fn fuse_base(&mut self, ops: &BaseOperationIr) -> bool {
    method fuse_float (line 425) | fn fuse_float(&mut self, ops: &FloatOperationIr) -> bool {
    method fuse_numeric (line 496) | fn fuse_numeric(&mut self, op: &NumericOperationIr) -> bool {
    method fuse_binary_ops (line 597) | fn fuse_binary_ops<Func>(&mut self, desc: &BinaryOpIr, func: Func) -> ...
    method fuse_unary_ops (line 616) | fn fuse_unary_ops<Func>(&mut self, desc: &UnaryOpIr, func: Func) -> bool
    method fuse_unary_op (line 623) | fn fuse_unary_op<Func>(&mut self, input: &TensorIr, out: &TensorIr, fu...
    method fuse_scalar_ops (line 639) | fn fuse_scalar_ops<Func>(&mut self, desc: &ScalarOpIr, func: Func) -> ...
    method output_is_compatible (line 659) | fn output_is_compatible(&mut self, out: &TensorIr) -> bool {
  type TryTraceFuser (line 719) | struct TryTraceFuser {
    method new (line 727) | fn new(max_bindings: u32, settings: FuseSettings) -> Self {
    method fuse (line 738) | fn fuse(&mut self, add_ops: impl FnOnce(&mut TraceFuser) -> Option<()>...
    method finish (line 766) | fn finish(&mut self, shape: Shape) -> FuseTrace {

FILE: crates/burn-cubecl-fusion/src/engine/launch/base.rs
  type FuseTraceLauncher (line 20) | pub struct FuseTraceLauncher<'a, R: Runtime, Runner: TraceRunner<R>> {
  function new (line 28) | pub fn new(trace: &'a FuseTrace, runner: &'a Runner) -> Self {
  function launch (line 36) | pub fn launch(
  function rollback (line 70) | fn rollback(

FILE: crates/burn-cubecl-fusion/src/engine/launch/executor.rs
  type LaunchPlanExecutor (line 24) | pub struct LaunchPlanExecutor<'a, R: Runtime> {
  type ExecutionError (line 31) | pub struct ExecutionError<R: Runtime, Runner: TraceRunner<R>> {
  function new (line 38) | pub fn new(resources: &'a FuseResources, blocks: &'a Vec<FuseBlock>) -> ...
  function execute (line 46) | pub fn execute<Runner: TraceRunner<R>>(
  function register_inputs (line 162) | fn register_inputs<R: Runtime>(
  function register_outputs (line 202) | fn register_outputs<R: Runtime>(
  function register_scalars (line 264) | fn register_scalars<'h, R: Runtime>(

FILE: crates/burn-cubecl-fusion/src/engine/launch/input.rs
  type InputPlanner (line 15) | pub struct InputPlanner<'a, R: Runtime> {
  function new (line 22) | pub fn new(resources: &'a FuseResources, blocks: &'a Vec<FuseBlock>) -> ...
  function run (line 30) | pub fn run(self, context: &mut Context<'_, CubeFusionHandle<R>>, plan: &...
  function analyze (line 106) | fn analyze(
  function analyze_normal (line 134) | fn analyze_normal(
  function analyze_view (line 192) | fn analyze_view(

FILE: crates/burn-cubecl-fusion/src/engine/launch/output.rs
  type OutputPlanner (line 27) | pub struct OutputPlanner<'a, R: Runtime> {
  type OutputSorted (line 36) | struct OutputSorted<'a> {
  type OutputKind (line 43) | enum OutputKind {
  function new (line 53) | pub fn new(resources: &'a FuseResources, blocks: &'a Vec<FuseBlock>) -> ...
  function run (line 94) | pub fn run(
  function select_reference_from_inputs (line 219) | fn select_reference_from_inputs(
  function add_layout_info_inputs (line 299) | fn add_layout_info_inputs(block: &mut BlockPlan<'_>, handle_inputs: &[Ha...
  function output_kind (line 323) | fn output_kind(
  function inplace_output (line 364) | fn inplace_output(
  function normal_output (line 450) | fn normal_output(
  function reshaped_output (line 531) | fn reshaped_output(
  function swapped_dims_output (line 609) | fn swapped_dims_output(
  function find_child_input (line 663) | fn find_child_input(
  function remove_concrete_write (line 681) | fn remove_concrete_write(block: &mut BlockPlan, id: TensorId, output_pos...

FILE: crates/burn-cubecl-fusion/src/engine/launch/plan.rs
  type LaunchPlan (line 20) | pub struct LaunchPlan<'a, R: Runtime> {
  type BlockPlan (line 44) | pub struct BlockPlan<'a> {
  type InputReference (line 61) | pub enum InputReference {
  type ReferenceSelection (line 77) | pub enum ReferenceSelection {
    method is_found (line 265) | pub fn is_found(&self) -> bool {
    method compatible_strides_for_inplace (line 269) | pub fn compatible_strides_for_inplace(&self, strides_inplace: &[usize]...
  function new (line 108) | pub fn new(fuse_blocks: &[FuseBlock]) -> Self {
  type HandleOutputAliasDebugInfo (line 141) | pub struct HandleOutputAliasDebugInfo<R: Runtime> {
  type HandleOutput (line 150) | pub enum HandleOutput<R: Runtime> {
  type NormalHandleInput (line 175) | pub struct NormalHandleInput<R: Runtime> {
  type QuantValuesHandleInput (line 188) | pub struct QuantValuesHandleInput<R: Runtime> {
  type QuantParamsHandleInput (line 198) | pub struct QuantParamsHandleInput<R: Runtime> {
  type HandleInput (line 206) | pub enum HandleInput<R: Runtime> {
  function as_normal (line 214) | pub fn as_normal(&self) -> Option<&NormalHandleInput<R>> {
  function new (line 224) | pub fn new(
  function handle_rollback (line 247) | pub fn handle_rollback(mut self) -> CubeFusionHandle<R> {
  type PotentialInplace (line 255) | pub struct PotentialInplace<'a> {

FILE: crates/burn-cubecl-fusion/src/engine/launch/runner.rs
  type TraceRunner (line 17) | pub trait TraceRunner<R: Runtime>: Vectorization<R> {
    method run (line 25) | fn run<'a>(
  type VectorizationHandle (line 34) | pub enum VectorizationHandle<'a, R: Runtime> {
  function is_from_tensor (line 42) | pub fn is_from_tensor(&self, id: TensorId) -> bool {
  type VectorizationAxis (line 52) | pub struct VectorizationAxis {
    method get (line 57) | pub fn get<F: FnOnce() -> usize>(&self, id: TensorId, default: F) -> u...
    method insert (line 60) | pub fn insert(&mut self, id: TensorId, axis: usize) {
  type Vectorization (line 65) | pub trait Vectorization<R: Runtime> {
    method axis (line 67) | fn axis(&self, _plan: &LaunchPlan<'_, R>) -> VectorizationAxis {
    method vectorization (line 72) | fn vectorization<'a>(

FILE: crates/burn-cubecl-fusion/src/engine/launch/vectorization/base.rs
  type Vect (line 12) | pub enum Vect {
    method vector_size (line 18) | pub fn vector_size(&self) -> VectorSize {
    method is_broadcast (line 25) | pub fn is_broadcast(&self) -> bool {
  type VectorSizeOverrides (line 31) | pub struct VectorSizeOverrides {
    method overrides (line 38) | pub fn overrides(&mut self, tensor_id: &TensorId, vector_sizes: Vec<Ve...
    method overrides_default (line 49) | pub fn overrides_default(&mut self, vector_sizes: Vec<VectorSize>) {
    method mapping (line 53) | pub fn mapping<R: Runtime>(&self, context: &Context<'_, CubeFusionHand...
    method tensor (line 75) | pub fn tensor(&self, tensor_id: &TensorId) -> Option<&Vec<VectorSize>> {
  function vectorization_default (line 95) | pub(crate) fn vectorization_default<'a, R: Runtime>(
  function multi_reads_vectorization_update (line 192) | fn multi_reads_vectorization_update(
  function vectorization_input (line 219) | fn vectorization_input<R: Runtime>(
  function vectorization_output (line 266) | fn vectorization_output(
  function vectorization_reshape (line 303) | fn vectorization_reshape(
  function vectorization_swapped (line 374) | fn vectorization_swapped<R: Runtime>(

FILE: crates/burn-cubecl-fusion/src/engine/launch/vectorization/planner.rs
  type VectorizationPlanner (line 30) | pub struct VectorizationPlanner<'a, R: Runtime> {
  function new (line 37) | pub fn new(resources: &'a FuseResources, blocks: &'a Vec<FuseBlock>) -> ...
  function run (line 44) | pub fn run<Runner: Vectorization<R>>(
  type VectorizationAction (line 315) | enum VectorizationAction {
  type BlockVectorization (line 321) | struct BlockVectorization {
  function apply_vectorization_block (line 327) | fn apply_vectorization_block<R: Runtime>(
  function vector_sizes_quants (line 378) | fn vector_sizes_quants<R: Runtime>(

FILE: crates/burn-cubecl-fusion/src/engine/scoring.rs
  type Scoring (line 9) | pub struct Scoring {
    method reset (line 17) | pub fn reset(&mut self) {
    method register (line 24) | pub fn register(&mut self, op: &OperationIr) {
    method evaluate (line 32) | pub fn evaluate(&self, trace: &FuseTrace) -> u64 {
    method calculate_score (line 55) | fn calculate_score(&self, reads_fused: usize, writes_fused: usize, num...
    method count_fused_io (line 78) | fn count_fused_io<F>(&self, ops: &[FuseOp], arg_extractor: F) -> (usiz...
  function test_scoring_io_savings (line 111) | fn test_scoring_io_savings() {
  function test_scoring_with_penalties (line 122) | fn test_scoring_with_penalties() {
  function test_penalty_outweighs_benefit (line 133) | fn test_penalty_outweighs_benefit() {
  function test_scoring_no_ops (line 144) | fn test_scoring_no_ops() {
  function test_reset (line 151) | fn test_reset() {

FILE: crates/burn-cubecl-fusion/src/engine/settings.rs
  type FuseSettings (line 5) | pub struct FuseSettings {
  method default (line 22) | fn default() -> Self {
  type VectorizationSetting (line 35) | pub enum VectorizationSetting {
  type RefLayoutSetting (line 48) | pub enum RefLayoutSetting {

FILE: crates/burn-cubecl-fusion/src/engine/trace/base.rs
  type FuseTrace (line 24) | pub struct FuseTrace {
    method fmt (line 30) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type TuneOutput (line 53) | pub enum TuneOutput<R: Runtime> {
  function merge (line 63) | pub fn merge(self, other: Self) -> Self {
  function check_equivalence (line 85) | fn check_equivalence(&self, other: Self) {
  type FuseResources (line 174) | pub struct FuseResources {
  type RuntimeLayout (line 196) | pub struct RuntimeLayout {
  method default (line 202) | fn default() -> Self {
  type TraceError (line 211) | pub enum TraceError<Err> {
  type TensorView (line 217) | pub enum TensorView {
  type RegisteredTensors (line 232) | pub struct RegisteredTensors {
    method iter (line 255) | pub fn iter(&self) -> impl Iterator<Item = &RegisterTensor> {
    method into_iter (line 260) | pub fn into_iter(self) -> impl Iterator<Item = RegisterTensor> {
    method len (line 265) | pub fn len(&self) -> usize {
    method get_id (line 270) | pub fn get_id(&self, index: usize) -> Option<TensorId> {
    method get_index (line 279) | pub fn get_index(&self, tensor_id: TensorId) -> Option<usize> {
    method get_index_quant (line 292) | pub fn get_index_quant(&self, tensor_id: TensorId) -> Option<usize> {
    method get (line 305) | pub fn get(&self, tensor_id: TensorId) -> Option<(&TensorIr, &FuseType...
    method insert_quant (line 325) | pub fn insert_quant(&mut self, tensor: TensorIr) -> (usize, usize) {
    method insert (line 347) | pub fn insert(&mut self, precision: FuseType, tensor: TensorIr) -> usi...
    method update (line 368) | pub fn update(&mut self, tensor: &TensorIr) {
  type RegisterTensor (line 237) | pub enum RegisterTensor {
    method as_normal_tensor (line 244) | pub fn as_normal_tensor(&self) -> Option<(&TensorIr, &FuseType)> {

FILE: crates/burn-cubecl-fusion/src/engine/trace/block.rs
  type FuseBlock (line 14) | pub struct FuseBlock {
  type FuseBlockBuilder (line 36) | pub struct FuseBlockBuilder {
    method new (line 62) | pub fn new(settings: FuseSettings) -> Self {
    method output (line 77) | pub fn output(&mut self, tensor: &TensorIr, resources: &mut FuseResour...
    method multi_block_variable (line 102) | pub fn multi_block_variable(
    method input (line 155) | pub fn input(&mut self, tensor: &TensorIr, resources: &mut FuseResourc...
    method input_quant (line 210) | pub fn input_quant(
    method input_swap_dims (line 258) | pub fn input_swap_dims(
    method input_reshaped (line 323) | pub fn input_reshaped(
    method build (line 398) | pub fn build(
    method tensor_writes (line 447) | pub fn tensor_writes(
  type QuantInput (line 53) | pub enum QuantInput {
  type LocalVariablePool (line 479) | pub struct LocalVariablePool {
    method get (line 484) | fn get(&self, precision: FuseType, tensor_id: TensorId) -> Option<Fuse...
    method get_any_precision (line 497) | fn get_any_precision(&self, tensor_id: TensorId) -> Option<FuseArg> {
    method create (line 510) | fn create(&mut self, precision: FuseType, tensor_id: TensorId) -> Fuse...

FILE: crates/burn-cubecl-fusion/src/engine/trace/fuser.rs
  type TraceFuser (line 21) | pub struct TraceFuser {
    method new (line 31) | pub fn new(settings: FuseSettings) -> Self {
    method num_previous_blocks (line 41) | pub fn num_previous_blocks(&self) -> usize {
    method fuse_dropped (line 46) | pub fn fuse_dropped(&mut self, tensor: &TensorIr) {
    method fuse_operation (line 53) | pub fn fuse_operation(&mut self, op: FuseOp) {
    method num_ops_fused (line 58) | pub fn num_ops_fused(&self) -> u32 {
    method next_block (line 70) | pub fn next_block(&mut self, shape_ref: Shape, settings: FuseSettings) {
    method estimate_bindings (line 80) | pub fn estimate_bindings(&self) -> u32 {
    method block_local_input (line 103) | pub fn block_local_input(
    method output_unhandled (line 137) | pub fn output_unhandled(&mut self, tensor: &TensorIr) -> FuseArg {
    method input_unhandled (line 150) | pub fn input_unhandled(&mut self, tensor: &TensorIr) -> FuseArg {
    method input_quantized_unhandled (line 166) | pub fn input_quantized_unhandled(&mut self, tensor: &TensorIr) -> Opti...
    method input (line 194) | pub fn input(&mut self, tensor: &TensorIr) -> Option<FuseArg> {
    method input_quantized (line 205) | pub fn input_quantized(&mut self, tensor: &TensorIr) -> Option<QuantIn...
    method output (line 211) | pub fn output(&mut self, tensor: &TensorIr) -> Option<FuseArg> {
    method input_indexed (line 219) | pub fn input_indexed(&mut self, tensor: &TensorIr) -> Option<FuseArg> {
    method input_swap_dims (line 244) | pub fn input_swap_dims(
    method input_reshaped (line 260) | pub fn input_reshaped(&mut self, tensor: &TensorIr, output: &TensorIr)...
    method scalar (line 271) | pub fn scalar(&mut self, elem: &ScalarIr, dtype: DType) -> FuseArg {
    method finish (line 286) | pub fn finish(&mut self, shape_ref: Shape) -> FuseTrace {

FILE: crates/burn-cubecl-fusion/src/optim/base.rs
  type CubeOptimization (line 14) | pub enum CubeOptimization<R: Runtime> {
  function fmt (line 22) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function to_opt_state (line 30) | pub fn to_opt_state(&self) -> CubeOptimizationState {
  function len (line 43) | fn len(&self) -> usize {
  type CubeOptimizationState (line 58) | pub enum CubeOptimizationState {

FILE: crates/burn-cubecl-fusion/src/optim/elemwise/fuser.rs
  type ElementWiseFuser (line 14) | pub struct ElementWiseFuser<R: Runtime> {
  method clone (line 20) | fn clone(&self) -> Self {
  function shape_id (line 29) | pub fn shape_id(&self) -> Shape {
  function new (line 32) | pub fn new(device: R::Device) -> Self {
  function fuse (line 54) | fn fuse(&mut self, operation: &burn_ir::OperationIr) {
  function finish (line 58) | fn finish(&mut self) -> CubeOptimization<R> {
  function reset (line 66) | fn reset(&mut self) {
  function status (line 70) | fn status(&self) -> burn_fusion::FuserStatus {
  function properties (line 74) | fn properties(&self) -> burn_fusion::FuserProperties {
  function len (line 78) | fn len(&self) -> usize {
  function clone_dyn (line 82) | fn clone_dyn(&self) -> Box<dyn OperationFuser<CubeOptimization<R>>> {

FILE: crates/burn-cubecl-fusion/src/optim/elemwise/optimization.rs
  type ElemwiseOptimization (line 26) | pub struct ElemwiseOptimization<R: Runtime> {
  type ElemwiseOptimizationState (line 35) | pub struct ElemwiseOptimizationState {
  function execute (line 42) | pub fn execute(&self, context: &mut Context<'_, CubeFusionHandle<R>>) {
  function num_ops_fused (line 54) | pub fn num_ops_fused(&self) -> usize {
  function from_state (line 59) | pub fn from_state(device: &R::Device, state: ElemwiseOptimizationState) ...
  function to_state (line 69) | pub fn to_state(&self) -> ElemwiseOptimizationState {
  type ElemwiseRunner (line 77) | pub struct ElemwiseRunner;
    type Error (line 81) | type Error = LaunchError;
    method run (line 83) | fn run<'a>(
  function elemwise_fuse (line 123) | fn elemwise_fuse(

FILE: crates/burn-cubecl-fusion/src/optim/matmul/args.rs
  type FusedMatmulArgs (line 37) | pub struct FusedMatmulArgs;
  type FusedMatmulInput (line 40) | pub struct FusedMatmulInput {
  type Output (line 56) | type Output<EO: CubePrimitive> = GlobalArgs;
  type Input (line 57) | type Input<Lhs: CubePrimitive, Rhs: CubePrimitive, EO: CubePrimitive> = ...
  type State (line 58) | type State<Lhs: CubePrimitive, Rhs: CubePrimitive, EO: CubePrimitive> = ...
  type Config (line 59) | type Config = ();
  method init_state (line 61) | fn init_state<Lhs: CubePrimitive, Rhs: CubePrimitive, EO: CubePrimitive>(
  method view_lhs (line 122) | fn view_lhs<Lhs: CubePrimitive, Rhs: CubePrimitive, EO: CubePrimitive>(
  method batch_lhs (line 135) | fn batch_lhs<Lhs: CubePrimitive, Rhs: CubePrimitive, EO: CubePrimitive>(
  method view_rhs (line 142) | fn view_rhs<Lhs: CubePrimitive, Rhs: CubePrimitive, EO: CubePrimitive>(
  method batch_rhs (line 155) | fn batch_rhs<Lhs: CubePrimitive, Rhs: CubePrimitive, EO: CubePrimitive>(
  method view_acc (line 162) | fn view_acc<Lhs: CubePrimitive, Rhs: CubePrimitive, EO: CubePrimitive>(
  method batch_acc (line 181) | fn batch_acc<Lhs: CubePrimitive, Rhs: CubePrimitive, EO: CubePrimitive>(
  method view_out (line 192) | fn view_out<Lhs: CubePrimitive, Rhs: CubePrimitive, EO: CubePrimitive>(
  method batch_out (line 223) | fn batch_out<Lhs: CubePrimitive, Rhs: CubePrimitive, EO: CubePrimitive>(
  method runtime_config (line 230) | fn runtime_config<Lhs: CubePrimitive, Rhs: CubePrimitive, EO: CubePrimit...
  function global_view (line 238) | fn global_view<E: CubePrimitive>(
  function input_batch_layout (line 342) | fn input_batch_layout(
  function global_layout (line 371) | fn global_layout(
  type CreateQuantView (line 404) | struct CreateQuantView<'a, E: Numeric, N: Size> {
  type Output (line 415) | type Output = ViewExpand<Vector<E, N>, BatchedCoords>;
  method execute (line 417) | fn execute<Q: Scalar, S: Scalar>(self) -> Self::Output {
  function create_quant_view_dynamic (line 431) | fn create_quant_view_dynamic<E: Numeric, N: Size>(
  function create_quant_view (line 453) | fn create_quant_view<E: Numeric, N: Size, Q: Scalar, S: Scalar>(
  type FusedMatmulState (line 470) | pub struct FusedMatmulState {
    method new (line 500) | pub fn new(
  type MatmulArg (line 537) | pub enum MatmulArg {
    method data (line 548) | pub fn data(&self) -> &FuseArg {
    method scheme (line 555) | pub fn scheme(&self) -> Option<&QuantScheme> {
    method precision (line 562) | pub fn precision(&self) -> FuseType {

FILE: crates/burn-cubecl-fusion/src/optim/matmul/fuser.rs
  type MatmulFuser (line 13) | pub struct MatmulFuser<R: Runtime> {
  method clone (line 21) | fn clone(&self) -> Self {
  function new (line 32) | pub fn new(device: R::Device) -> Self {
  function fuse (line 52) | fn fuse(&mut self, operation: &OperationIr) {
  function finish (line 115) | fn finish(&mut self) -> CubeOptimization<R> {
  function reset (line 132) | fn reset(&mut self) {
  function status (line 138) | fn status(&self) -> burn_fusion::FuserStatus {
  function properties (line 142) | fn properties(&self) -> burn_fusion::FuserProperties {
  function len (line 146) | fn len(&self) -> usize {
  function clone_dyn (line 151) | fn clone_dyn(&self) -> Box<dyn OperationFuser<CubeOptimization<R>>> {

FILE: crates/burn-cubecl-fusion/src/optim/matmul/optimization.rs
  type MatmulOptimization (line 49) | pub struct MatmulOptimization<R: Runtime> {
  type MatmulOptimizationTuneArg (line 53) | pub struct MatmulOptimizationTuneArg<R: Runtime> {
  type MatmulOptimizationInfo (line 58) | pub(crate) struct MatmulOptimizationInfo<R: Runtime> {
  type MatmulOptimizationState (line 69) | pub struct MatmulOptimizationState {
  function num_output_buffers (line 78) | pub fn num_output_buffers(&self) -> usize {
  function num_ops_fused (line 83) | pub fn num_ops_fused(&self) -> usize {
  function execute_fused (line 89) | pub(crate) fn execute_fused(
  function execute_fallback (line 100) | pub fn execute_fallback(
  function new (line 136) | pub fn new(
  function execute (line 158) | pub fn execute(
  function num_ops_fused (line 183) | pub fn num_ops_fused(&self) -> usize {
  function from_state (line 188) | pub fn from_state(device: &R::Device, state: MatmulOptimizationState) ->...
  function to_state (line 204) | pub fn to_state(&self) -> MatmulOptimizationState {
  type FusedMatmulSelector (line 215) | pub enum FusedMatmulSelector {
    method name (line 235) | pub fn name(&self) -> String {
  method default (line 265) | fn default() -> Self {
  type FusedMatmul (line 274) | pub struct FusedMatmul {
  type FusedMatmulLaunch (line 283) | pub struct FusedMatmulLaunch<'a> {
  type FusedMatmulError (line 289) | pub enum FusedMatmulError {
    method from (line 295) | fn from(value: MatmulSetupError) -> Self {
  function axis (line 301) | fn axis(&self, plan: &LaunchPlan<'_, R>) -> VectorizationAxis {
  type Error (line 354) | type Error = FusedMatmulError;
  function run (line 356) | fn run<'a>(
  type AcceleratedTileKind (line 375) | pub enum AcceleratedTileKind {
  function matmul_fused (line 397) | fn matmul_fused<'a, R: Runtime>(
  function launch_inner_fix_dtype (line 634) | fn launch_inner_fix_dtype<R: Runtime, A: Routine<()>>(

FILE: crates/burn-cubecl-fusion/src/optim/matmul/tune.rs
  type FusedMatmulAutotuneKey (line 20) | pub struct FusedMatmulAutotuneKey {
  function fused_matmul_autotune (line 29) | pub fn fused_matmul_autotune<R: Runtime>(
  function create_key (line 189) | pub(crate) fn create_key<R: Runtime>(
  function input_gen (line 228) | fn input_gen<R: Runtime>(
  function tune_fused (line 235) | fn tune_fused<R: Runtime>(
  function tune_fallback (line 256) | fn tune_fallback<R: Runtime>(

FILE: crates/burn-cubecl-fusion/src/optim/reduce/args.rs
  type FusedReduceArgs (line 10) | pub struct FusedReduceArgs;
  type FusedReduceInput (line 13) | pub struct FusedReduceInput {
  type FusedReduceOutput (line 22) | pub struct FusedReduceOutput {
  type FusedReduceState (line 30) | pub struct FusedReduceState {
    method new (line 189) | pub fn new(
  type FusedReduceStateExpand (line 43) | pub struct FusedReduceStateExpand {
  type Input (line 56) | type Input<E: Numeric, S: Size> = FusedReduceInput;
  type Output (line 57) | type Output<E: Numeric, S: Size> = FusedReduceOutput;
  type State (line 58) | type State<P: ReduceDType> = FusedReduceState;
  method init_state (line 60) | fn init_state<P: ReduceDType>(
  method read_input (line 70) | fn read_input<P: ReduceDType>(
  method read_output (line 90) | fn read_output<P: ReduceDType>(
  method write_output (line 97) | fn write_output<P: ReduceDType>(
  method len_input (line 118) | fn len_input<P: ReduceDType>(state: &Self::State<P>) -> usize {
  method len_output (line 127) | fn len_output<P: ReduceDType>(state: &Self::State<P>) -> usize {
  method buffer_len_input (line 136) | fn buffer_len_input<P: ReduceDType>(state: &Self::State<P>) -> usize {
  method buffer_len_output (line 145) | fn buffer_len_output<P: ReduceDType>(state: &Self::State<P>) -> usize {
  method rank_input (line 154) | fn rank_input<P: ReduceDType>(state: &Self::State<P>) -> usize {
  method rank_output (line 158) | fn rank_output<P: ReduceDType>(state: &Self::State<P>) -> usize {
  method shape_input (line 162) | fn shape_input<P: ReduceDType>(state: &Self::State<P>, dim: usize) -> us...
  method shape_output (line 166) | fn shape_output<P: ReduceDType>(state: &Self::State<P>, dim: usize) -> u...
  method stride_input (line 170) | fn stride_input<P: ReduceDType>(state: &Self::State<P>, dim: usize) -> u...
  method stride_output (line 174) | fn stride_output<P: ReduceDType>(state: &Self::State<P>, dim: usize) -> ...
  method vector_size_input (line 178) | fn vector_size_input<P: ReduceDType>(state: &Self::State<P>) -> comptime...
  method vector_size_output (line 182) | fn vector_size_output<P: ReduceDType>(state: &Self::State<P>) -> comptim...
  type ExpandType (line 209) | type ExpandType = FusedReduceStateExpand;
  method into_mut (line 213) | fn into_mut(self, _context: &mut Scope) -> Self {

FILE: crates/burn-cubecl-fusion/src/optim/reduce/fuser.rs
  type ReduceFuser (line 19) | pub struct ReduceFuser<R: Runtime> {
  method clone (line 30) | fn clone(&self) -> Self {
  type ReduceFuserInfo (line 44) | pub enum ReduceFuserInfo {
  function new (line 50) | pub fn new(device: R::Device, settings: ReduceSettings) -> Self {
  function reduce_info (line 82) | pub fn reduce_info(&self) -> ReduceFuserInfo {
  function on_reduce (line 99) | fn on_reduce(&mut self, op: &ReduceDimOpIr, inst: ReduceInstruction) {
  function on_elemwise_read (line 159) | fn on_elemwise_read(&mut self, operation: &OperationIr) {
  function on_elemwise_write (line 175) | fn on_elemwise_write(&mut self, operation: &OperationIr) {
  function fuse (line 193) | fn fuse(&mut self, operation: &OperationIr) {
  function finish (line 267) | fn finish(&mut self) -> CubeOptimization<R> {
  function reset (line 289) | fn reset(&mut self) {
  function status (line 296) | fn status(&self) -> burn_fusion::FuserStatus {
  function properties (line 300) | fn properties(&self) -> burn_fusion::FuserProperties {
  function len (line 306) | fn len(&self) -> usize {
  function clone_dyn (line 310) | fn clone_dyn(&self) -> Box<dyn OperationFuser<CubeOptimization<R>>> {

FILE: crates/burn-cubecl-fusion/src/optim/reduce/optimization.rs
  type ReduceOptimization (line 41) | pub struct ReduceOptimization<R: Runtime> {
  type ReduceOptimizationInfo (line 45) | pub(crate) struct ReduceOptimizationInfo<R: Runtime> {
  function from_state (line 58) | pub fn from_state(device: &R::Device, state: ReduceOptimizationState) ->...
  function to_state (line 73) | pub fn to_state(&self) -> ReduceOptimizationState {
  type ReduceSettings (line 87) | pub enum ReduceSettings {
  type ReduceOptimizationTuneArg (line 97) | pub(crate) struct ReduceOptimizationTuneArg<R: Runtime> {
  method clone (line 103) | fn clone(&self) -> Self {
  type ReduceInstruction (line 112) | pub enum ReduceInstruction {
  type ReduceFallbackFn (line 123) | pub trait ReduceFallbackFn<R: Runtime>: Send + Sync {
    method run (line 124) | fn run(&self, context: &mut Context<'_, CubeFusionHandle<R>>);
  type ReduceOptimizationState (line 128) | pub struct ReduceOptimizationState {
    method fmt (line 139) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type FusedReduce (line 148) | pub struct FusedReduce {
  type FusedReduceLaunch (line 160) | pub struct FusedReduceLaunch<'a> {
  type FusedReduceError (line 166) | pub enum FusedReduceError {
    method from (line 173) | fn from(value: ReduceError) -> Self {
  function execute_fused (line 179) | pub fn execute_fused(
  function execute_fallback (line 189) | pub fn execute_fallback(
  function new (line 227) | pub fn new(
  function execute (line 255) | pub fn execute(
  function num_output_buffers (line 282) | pub fn num_output_buffers(&self) -> usize {
  function to_state (line 286) | pub fn to_state(&self) -> ReduceOptimizationState {
  function from_state (line 298) | pub fn from_state(device: &R::Device, state: ReduceOptimizationState) ->...
  function num_ops_fused (line 319) | pub fn num_ops_fused(&self) -> usize {
  type Error (line 328) | type Error = FusedReduceError;
  function run (line 330) | fn run<'a>(
  type ReduceKwArgs (line 417) | struct ReduceKwArgs<'b, Run: Runtime> {
  function launch_reduce_mixed_precision (line 430) | fn launch_reduce_mixed_precision<Run: Runtime>(
  function launch_reduce (line 450) | fn launch_reduce<Run: Runtime>(
  function reduce_kernel_fused (line 480) | pub fn reduce_kernel_fused<In: Numeric, SizeIn: Size, Out: Numeric, Size...

FILE: crates/burn-cubecl-fusion/src/optim/reduce/tune.rs
  type FusedReduceAutotuneKey (line 23) | pub struct FusedReduceAutotuneKey {
  function fused_reduce_autotune (line 37) | pub fn fused_reduce_autotune<R: Runtime>(
  function create_key (line 119) | pub(crate) fn create_key<R: Runtime>(
  function input_gen (line 154) | fn input_gen<R: Runtime>(
  function tune_reduce (line 162) | fn tune_reduce<R: Runtime>(
  function tune_fallback (line 178) | fn tune_fallback<R: Runtime>(

FILE: crates/burn-cubecl-fusion/src/optim/reduce_broadcasted/fuser/base.rs
  type ReduceBroadcastedFuser (line 19) | pub struct ReduceBroadcastedFuser<R: Runtime> {
  method clone (line 28) | fn clone(&self) -> Self {
  function new (line 40) | pub fn new(device: R::Device) -> Self {
  function fuse (line 56) | fn fuse(&mut self, operation: &OperationIr) {
  function finish (line 106) | fn finish(&mut self) -> CubeOptimization<R> {
  function reset (line 124) | fn reset(&mut self) {
  function status (line 131) | fn status(&self) -> FuserStatus {
  function properties (line 143) | fn properties(&self) -> FuserProperties {
  function len (line 164) | fn len(&self) -> usize {
  function clone_dyn (line 168) | fn clone_dyn(&self) -> Box<dyn OperationFuser<CubeOptimization<R>>> {
  type Run (line 182) | type Run = cubecl::TestRuntime;
  function reduce_broadcast_workflow_1 (line 185) | fn reduce_broadcast_workflow_1() {
  function reduce_broadcast_workflow_2 (line 261) | fn reduce_broadcast_workflow_2() {
  function tensor (line 320) | fn tensor(id: u64, shape: &[usize], status: TensorStatus) -> (TensorIr, ...

FILE: crates/burn-cubecl-fusion/src/optim/reduce_broadcasted/fuser/block.rs
  type ReduceBlockFuser (line 17) | pub struct ReduceBlockFuser<R: Runtime> {
  type ReduceBroadcastedStatus (line 32) | pub enum ReduceBroadcastedStatus {
  type ReduceBlockFusionAnalysis (line 49) | pub enum ReduceBlockFusionAnalysis {
  function new (line 60) | pub fn new(fuser: ReduceFuser<R>) -> Self {
  function is_elemwise (line 69) | pub fn is_elemwise(&self) -> bool {
  function analyze (line 74) | pub fn analyze(
  function fuse (line 144) | pub fn fuse(&mut self, op: &OperationIr) {
  function properties (line 158) | pub fn properties(&self) -> FuserProperties {
  function finish (line 167) | pub fn finish(
  type ReduceBlockKind (line 198) | pub enum ReduceBlockKind {
  method clone (line 207) | fn clone(&self) -> Self {

FILE: crates/burn-cubecl-fusion/src/optim/reduce_broadcasted/fuser/full.rs
  type ReduceBroadcastedFullFuser (line 23) | pub struct ReduceBroadcastedFullFuser {
    method new (line 33) | pub fn new(max_bindings: u32, analyzer: FullFuserAnalyzer) -> Self {
    method finish (line 61) | pub fn finish(mut self) -> ReduceBroadcastedInfo {
    method register (line 101) | pub fn register<R: Runtime>(&mut self, block: &ReduceBlockFuser<R>) {

FILE: crates/burn-cubecl-fusion/src/optim/reduce_broadcasted/fuser/full_analyzer.rs
  type FullFuserAnalyzer (line 8) | pub struct FullFuserAnalyzer {
    method new (line 14) | pub fn new<R: Runtime>(blocks: &[ReduceBlockFuser<R>]) -> Self {
    method retrieve_next (line 60) | pub fn retrieve_next(&mut self) -> FullFuserAnalysis {
  type FullFuserAnalysis (line 67) | pub struct FullFuserAnalysis {
  type AnalysisState (line 73) | struct AnalysisState {
    method next_block (line 92) | fn next_block(&mut self) {
    method register (line 112) | fn register<'a>(
  type BlockKind (line 86) | enum BlockKind {

FILE: crates/burn-cubecl-fusion/src/optim/reduce_broadcasted/launch.rs
  type ReduceBroadcastedFuseBlock (line 28) | pub struct ReduceBroadcastedFuseBlock {
  type FusedReduceBroadcastedLaunch (line 35) | pub struct FusedReduceBroadcastedLaunch<'a> {
  type Error (line 45) | type Error = LaunchError;
  function run (line 47) | fn run<'a>(

FILE: crates/burn-cubecl-fusion/src/optim/reduce_broadcasted/optimization.rs
  type ReduceBroadcastedOptimization (line 24) | pub struct ReduceBroadcastedOptimization<R: Runtime> {
  type ReduceBroadcastedOptimizationInfo (line 29) | pub(crate) struct ReduceBroadcastedOptimizationInfo<R: Runtime> {
  type ReduceBroadcastedInfo (line 35) | pub(crate) struct ReduceBroadcastedInfo {
  type ReduceBlockOptimInfo (line 41) | pub(crate) enum ReduceBlockOptimInfo<R: Runtime> {
  function from_state (line 47) | pub fn from_state(device: &R::Device, state: ReduceBlockState) -> Self {
  function to_state (line 57) | pub fn to_state(&self) -> ReduceBlockState {
  type ReduceBroadcastedOptimizationTuneArg (line 65) | pub(crate) struct ReduceBroadcastedOptimizationTuneArg<R: Runtime> {
  type ReduceBlockOptimArg (line 72) | pub(crate) enum ReduceBlockOptimArg<R: Runtime> {
  function execute_fallback (line 78) | pub fn execute_fallback(
  type ReduceBroadcastedOptimizationState (line 101) | pub struct ReduceBroadcastedOptimizationState {
  type ReduceBlockState (line 109) | pub enum ReduceBlockState {
  function execute_fused (line 115) | pub fn execute_fused(
  function execute_fallback (line 132) | pub fn execute_fallback(&self, context: &mut Context<'_, CubeFusionHandl...
  function execute (line 142) | pub fn execute(
  function to_state (line 188) | pub fn to_state(&self) -> ReduceBroadcastedOptimizationState {
  function from_state (line 201) | pub fn from_state(device: &R::Device, state: ReduceBroadcastedOptimizati...
  function num_ops_fused (line 216) | pub fn num_ops_fused(&self) -> usize {

FILE: crates/burn-cubecl-fusion/src/optim/reduce_broadcasted/tune.rs
  type FusedBroadcastedReduceAutotuneKey (line 24) | pub struct FusedBroadcastedReduceAutotuneKey {
  function fused_broadcasted_reduce_autotune (line 39) | pub fn fused_broadcasted_reduce_autotune<R: Runtime>(
  function create_key (line 83) | pub(crate) fn create_key<R: Runtime>(
  function generate_reduce_autotune_key (line 121) | fn generate_reduce_autotune_key<R: Runtime>(
  function input_gen (line 140) | fn input_gen<R: Runtime>(
  function tune_reduce (line 148) | fn tune_reduce<R: Runtime>(
  function tune_fallback (line 164) | fn tune_fallback<R: Runtime>(

FILE: crates/burn-cubecl-fusion/src/optim/reduce_broadcasted/unit.rs
  type ReduceFuseBlock (line 26) | pub struct ReduceFuseBlock {
  type ElemwiseFuseBlock (line 43) | pub struct ElemwiseFuseBlock {
  function reduce_kernel_broadcasted (line 61) | pub fn reduce_kernel_broadcasted(
  function set_polyfill_block (line 87) | fn set_polyfill_block(block: &ReduceFuseBlock) {
  function reduce_many (line 119) | fn reduce_many(
  function reduce_step (line 189) | fn reduce_step<P: ReducePrecision, Out: NumericLine, I: ReduceInstructio...

FILE: crates/burn-cubecl-fusion/src/tune.rs
  type TuneContext (line 11) | pub enum TuneContext<'a, R: Runtime> {
  type TuneInput (line 22) | pub struct TuneInput<R: Runtime, O> {
  type UnsafeTuneContext (line 37) | enum UnsafeTuneContext<R: Runtime> {
  function new (line 47) | pub fn new(context: &mut Context<CubeFusionHandle<R>>, optimization: O) ...
  function context (line 57) | pub fn context(&self) -> TuneContext<'static, R> {
  function optimization (line 62) | pub fn optimization(&self) -> &O {
  function new (line 68) | fn new(context: &mut Context<'_, CubeFusionHandle<R>>) -> Self {
  function get (line 76) | fn get(&self) -> TuneContext<'static, R> {
  method clone (line 87) | fn clone(&self) -> Self {
  method clone (line 96) | fn clone(&self) -> Self {

FILE: crates/burn-cubecl/src/backend.rs
  type CubeBackend (line 17) | pub struct CubeBackend<R: CubeRuntime, F: FloatElement, I: IntElement, B...
  type Device (line 33) | type Device = R::Device;
  type FloatElem (line 35) | type FloatElem = F;
  type IntElem (line 36) | type IntElem = I;
  type BoolElem (line 37) | type BoolElem = BT;
  type FloatTensorPrimitive (line 39) | type FloatTensorPrimitive = CubeTensor<R>;
  type IntTensorPrimitive (line 40) | type IntTensorPrimitive = CubeTensor<R>;
  type BoolTensorPrimitive (line 41) | type BoolTensorPrimitive = CubeTensor<R>;
  type QuantizedTensorPrimitive (line 42) | type QuantizedTensorPrimitive = CubeTensor<R>;
  method name (line 44) | fn name(device: &Self::Device) -> String {
  method seed (line 49) | fn seed(_device: &Self::Device, seed: u64) {
  method ad_enabled (line 53) | fn ad_enabled(_device: &Self::Device) -> bool {
  method sync (line 57) | fn sync(device: &Self::Device) -> Result<(), ExecutionError> {
  method memory_persistent_allocations (line 64) | fn memory_persistent_allocations<
  method memory_cleanup (line 77) | fn memory_cleanup(device: &Self::Device) {
  method staging (line 82) | fn staging<'a, Iter>(data: Iter, device: &Self::Device)
  method supports_dtype (line 90) | fn supports_dtype(device: &Self::Device, dtype: DType) -> bool {
  method dtype_usage (line 103) | fn dtype_usage(device: &Self::Device, dtype: DType) -> DTypeUsageSet {
  function fmt (line 134) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method clone (line 142) | fn clone(&self) -> Self {
  method default (line 150) | fn default() -> Self {
  type CubeDevice (line 159) | type CubeDevice = R::Device;
  type CubeServer (line 160) | type CubeServer = R::Server;
  type Handle (line 167) | type Handle = CubeTensor<R>;
  method float_tensor (line 169) | fn float_tensor(handle: TensorHandle<Self::Handle>) -> FloatTensor<Self> {
  method int_tensor (line 173) | fn int_tensor(handle: TensorHandle<Self::Handle>) -> IntTensor<Self> {
  method bool_tensor (line 177) | fn bool_tensor(handle: TensorHandle<Self::Handle>) -> BoolTensor<Self> {
  method quantized_tensor (line 181) | fn quantized_tensor(handle: TensorHandle<Self::Handle>) -> QuantizedTens...
  method float_tensor_handle (line 185) | fn float_tensor_handle(tensor: FloatTensor<Self>) -> Self::Handle {
  method int_tensor_handle (line 189) | fn int_tensor_handle(tensor: IntTensor<Self>) -> Self::Handle {
  method bool_tensor_handle (line 193) | fn bool_tensor_handle(tensor: BoolTensor<Self>) -> Self::Handle {
  method quantized_tensor_handle (line 197) | fn quantized_tensor_handle(tensor: QuantizedTensor<Self>) -> Self::Handle {

FILE: crates/burn-cubecl/src/element.rs
  type CubeElement (line 13) | pub trait CubeElement: Element + CubeElem + PartialEq + Numeric {}
  type MatmulElement (line 16) | pub trait MatmulElement:
  type FloatElement (line 22) | pub trait FloatElement: MatmulElement + Float {}
  type IntElement (line 25) | pub trait IntElement:
  type BoolElement (line 31) | pub trait BoolElement: CubeElement + Int {
    method true_val (line 33) | fn true_val() -> Self {
    method false_val (line 38) | fn false_val() -> Self {
    method new_bool (line 43) | fn new_bool(val: bool) -> Self {
  function bool_dtype (line 99) | pub(crate) fn bool_dtype<BT: burn_backend::Element>() -> DType {

FILE: crates/burn-cubecl/src/fusion.rs
  function execute (line 30) | fn execute(
  function to_state (line 55) | fn to_state(&self) -> CubeOptimizationState {
  function from_state (line 59) | fn from_state(device: &R::Device, state: CubeOptimizationState) -> Self {
  type FallbackOperationWrapper (line 77) | struct FallbackOperationWrapper<O: Clone> {
  function new (line 82) | fn new(op: O) -> Self {
  function run (line 90) | fn run(&self, context: &mut burn_fusion::stream::Context<'_, CubeFusionH...
  type Handle (line 98) | type Handle = CubeFusionHandle<R>;
  method float_tensor (line 100) | fn float_tensor(handle: TensorHandle<Self::Handle>) -> FloatTensor<Self> {
  method int_tensor (line 104) | fn int_tensor(handle: TensorHandle<Self::Handle>) -> IntTensor<Self> {
  method bool_tensor (line 108) | fn bool_tensor(handle: TensorHandle<Self::Handle>) -> BoolTensor<Self> {
  method quantized_tensor (line 112) | fn quantized_tensor(handle: TensorHandle<Self::Handle>) -> QuantizedTens...
  method float_tensor_handle (line 116) | fn float_tensor_handle(tensor: FloatTensor<Self>) -> Self::Handle {
  method int_tensor_handle (line 120) | fn int_tensor_handle(tensor: IntTensor<Self>) -> Self::Handle {
  method bool_tensor_handle (line 124) | fn bool_tensor_handle(tensor: BoolTensor<Self>) -> Self::Handle {
  method quantized_tensor_handle (line 128) | fn quantized_tensor_handle(tensor: QuantizedTensor<Self>) -> Self::Handle {
  type OptimizationState (line 134) | type OptimizationState = CubeOptimizationState;
  type Optimization (line 135) | type Optimization = CubeOptimization<R>;
  type FusionHandle (line 136) | type FusionHandle = CubeFusionHandle<R>;
  type FusionDevice (line 137) | type FusionDevice = R::CubeDevice;
  method fusers (line 139) | fn fusers(device: R::Device) -> Vec<Box<dyn burn_fusion::OperationFuser<...
  type FusionCubeRuntime (line 151) | pub struct FusionCubeRuntime<R: CubeRuntime> {
  type FusionRuntime (line 158) | type FusionRuntime = FusionCubeRuntime<R>;
  type FullPrecisionBackend (line 160) | type FullPrecisionBackend = CubeBackend<R, f32, i32, BT>;
  method cast_float (line 162) | fn cast_float(tensor: FloatTensor<Self>, dtype: DType) -> Self::Handle {
  function into_tensor (line 167) | fn into_tensor<R: CubeRuntime>(handle: CubeFusionHandle<R>, shape: Shape...
  function from (line 179) | fn from(value: CubeTensor<R>) -> Self {

FILE: crates/burn-cubecl/src/kernel/attention/base.rs
  type AttentionStrategy (line 19) | pub enum AttentionStrategy {
  method default (line 35) | fn default() -> Self {
  function attention (line 48) | pub fn attention<R: CubeRuntime>(
  function flash_attention (line 97) | pub fn flash_attention<R: CubeRuntime>(
  function init_attention_output (line 137) | pub(crate) fn init_attention_output<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/attention/tune.rs
  function attention_autotune (line 14) | pub fn attention_autotune<R: CubeRuntime>(
  function create_key (line 129) | fn create_key<R: CubeRuntime>(
  function input_gen (line 160) | fn input_gen<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/binary.rs
  type BinaryOpFamily (line 12) | pub(crate) trait BinaryOpFamily: Send + Sync + 'static {
    type BinaryOp (line 32) | type BinaryOp<C: Numeric, N: Size> = Self;
    type BinaryOp (line 36) | type BinaryOp<C: Numeric, N: Size> = Self;
    type BinaryOp (line 40) | type BinaryOp<C: Numeric, N: Size> = Self;
    type BinaryOp (line 44) | type BinaryOp<C: Numeric, N: Size> = Self;
    type BinaryOp (line 48) | type BinaryOp<C: Numeric, N: Size> = Self;
    type BinaryOp (line 52) | type BinaryOp<C: Numeric, N: Size> = Self;
    type BinaryOp (line 56) | type BinaryOp<C: Numeric, N: Size> = Self;
    type BinaryOp (line 60) | type BinaryOp<C: Numeric, N: Size> = Self;
  type BinaryOp (line 17) | pub(crate) trait BinaryOp<C: Numeric, N: Size>: 'static + Send + Sync {
    method execute (line 19) | fn execute(lhs: Vector<C, N>, rhs: Vector<C, N>) -> Vector<C, N>;
  type AddOp (line 22) | pub(crate) struct AddOp;
    method execute (line 65) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  type SubOp (line 23) | pub(crate) struct SubOp;
    method execute (line 72) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  type MulOp (line 24) | pub(crate) struct MulOp;
    method execute (line 79) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  type DivOp (line 25) | pub(crate) struct DivOp;
    method execute (line 86) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  type RemainderOp (line 26) | pub(crate) struct RemainderOp;
    method execute (line 93) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  type AndOp (line 27) | pub(crate) struct AndOp;
    method execute (line 139) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  type OrOp (line 28) | pub(crate) struct OrOp;
    method execute (line 146) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  type PowOp (line 29) | pub(crate) struct PowOp;
    method execute (line 101) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  function kernel_scalar_binop (line 152) | pub(crate) fn kernel_scalar_binop<C: Numeric, N: Size, O: BinaryOpFamily>(
  function kernel_binop (line 167) | pub(crate) fn kernel_binop<C: Numeric, N: Size, O: BinaryOpFamily>(
  function launch_binop (line 180) | pub(crate) fn launch_binop<R: CubeRuntime, O: BinaryOpFamily>(
  function launch_scalar_binop (line 248) | pub(crate) fn launch_scalar_binop<R: CubeRuntime, O: BinaryOpFamily>(

FILE: crates/burn-cubecl/src/kernel/binary_float.rs
  type BinaryOpFloatFamily (line 9) | pub(crate) trait BinaryOpFloatFamily: Send + Sync + 'static {
    type BinaryOp (line 22) | type BinaryOp<C: Float, N: Size> = Self;
  type BinaryOpFloat (line 14) | pub(crate) trait BinaryOpFloat<C: Float, N: Size>: 'static + Send + Sync {
    method execute (line 16) | fn execute(lhs: Vector<C, N>, rhs: Vector<C, N>) -> Vector<C, N>;
  type ArcTan2Op (line 19) | pub(crate) struct ArcTan2Op;
    method execute (line 27) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  function kernel_binop (line 33) | pub(crate) fn kernel_binop<C: Float, N: Size, O: BinaryOpFloatFamily>(
  function launch_binop_float (line 46) | pub(crate) fn launch_binop_float<R: CubeRuntime, O: BinaryOpFloatFamily>(
  function atan2 (line 115) | pub fn atan2<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: CubeTensor<R>) -> ...

FILE: crates/burn-cubecl/src/kernel/binary_int.rs
  type BinaryOpIntFamily (line 10) | pub(crate) trait BinaryOpIntFamily: Send + Sync + 'static {
    type BinaryOp (line 27) | type BinaryOp<C: Int, N: Size> = Self;
    type BinaryOp (line 31) | type BinaryOp<C: Int, N: Size> = Self;
    type BinaryOp (line 35) | type BinaryOp<C: Int, N: Size> = Self;
    type BinaryOp (line 39) | type BinaryOp<C: Int, N: Size> = Self;
    type BinaryOp (line 43) | type BinaryOp<C: Int, N: Size> = Self;
  type BinaryOpInt (line 15) | pub(crate) trait BinaryOpInt<C: Int, N: Size>: 'static + Send + Sync {
    method execute (line 17) | fn execute(lhs: Vector<C, N>, rhs: Vector<C, N>) -> Vector<C, N>;
  type BitwiseAndOp (line 20) | pub(crate) struct BitwiseAndOp;
    method execute (line 48) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  type BitwiseOrOp (line 21) | pub(crate) struct BitwiseOrOp;
    method execute (line 55) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  type BitwiseXorOp (line 22) | pub(crate) struct BitwiseXorOp;
    method execute (line 62) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  type BitwiseShrOp (line 23) | pub(crate) struct BitwiseShrOp;
    method execute (line 69) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  type BitwiseShlOp (line 24) | pub(crate) struct BitwiseShlOp;
    method execute (line 76) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> Vector<T, N> {
  function kernel_scalar_binop_int (line 82) | pub(crate) fn kernel_scalar_binop_int<C: Int, N: Size, O: BinaryOpIntFam...
  function kernel_binop_int (line 97) | pub(crate) fn kernel_binop_int<C: Int, N: Size, O: BinaryOpIntFamily>(
  function launch_binop_int (line 110) | pub(crate) fn launch_binop_int<R: CubeRuntime, O: BinaryOpIntFamily>(
  function launch_scalar_binop_int (line 178) | pub(crate) fn launch_scalar_binop_int<R: CubeRuntime, O: BinaryOpIntFami...

FILE: crates/burn-cubecl/src/kernel/cast/base.rs
  function cast_element (line 12) | pub(crate) fn cast_element<I: Numeric, O: Numeric, N: Size>(
  function cast (line 27) | pub fn cast<R: CubeRuntime>(input: CubeTensor<R>, dtype: DType) -> CubeT...

FILE: crates/burn-cubecl/src/kernel/cast/bool_cast.rs
  function bool_cast_kernel (line 14) | fn bool_cast_kernel<B: Int, T: Numeric, N: Size>(
  function bool_cast (line 32) | pub fn bool_cast<R: CubeRuntime, EO: CubeElement>(tensor: CubeTensor<R>)...

FILE: crates/burn-cubecl/src/kernel/clamp.rs
  type Options (line 10) | struct Options {
  function clamp (line 15) | pub(crate) fn clamp<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/comparison.rs
  type ComparisonOpFamily (line 11) | pub(crate) trait ComparisonOpFamily: 'static + Send + Sync {
    type Operation (line 28) | type Operation<T: Numeric, N: Size> = Self;
    type Operation (line 39) | type Operation<T: Numeric, N: Size> = Self;
    type Operation (line 50) | type Operation<T: Numeric, N: Size> = Self;
    type Operation (line 61) | type Operation<T: Numeric, N: Size> = Self;
    type Operation (line 72) | type Operation<T: Numeric, N: Size> = Self;
  type ComparisonOp (line 16) | pub(crate) trait ComparisonOp<C: Numeric, N: Size>: 'static + Send + Sync {
    method execute (line 18) | fn execute(lhs: Vector<C, N>, rhs: Vector<C, N>) -> bool;
  type EqualOp (line 21) | struct EqualOp;
    method execute (line 33) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> bool {
  type GreaterEqualOp (line 22) | struct GreaterEqualOp;
    method execute (line 44) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> bool {
  type LowerEqualOp (line 23) | struct LowerEqualOp;
    method execute (line 55) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> bool {
  type GreaterOp (line 24) | struct GreaterOp;
    method execute (line 66) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> bool {
  type LowerOp (line 25) | struct LowerOp;
    method execute (line 77) | fn execute(lhs: Vector<T, N>, rhs: Vector<T, N>) -> bool {
  function kernel_scalar_cmp (line 83) | pub(crate) fn kernel_scalar_cmp<T: Numeric, Bool: Numeric, N: Size, O: C...
  function kernel_cmp (line 100) | pub(crate) fn kernel_cmp<T: Numeric, Bool: Numeric, N: Size, O: Comparis...
  function launch_cmp (line 116) | pub(crate) fn launch_cmp<R: CubeRuntime, O: ComparisonOpFamily>(
  function launch_scalar_cmp (line 206) | pub(crate) fn launch_scalar_cmp<R: CubeRuntime, O: ComparisonOpFamily>(
  function equal (line 270) | pub fn equal<R: CubeRuntime>(
  function greater (line 278) | pub fn greater<R: CubeRuntime>(
  function greater_equal (line 286) | pub fn greater_equal<R: CubeRuntime>(
  function lower (line 294) | pub fn lower<R: CubeRuntime>(
  function lower_equal (line 302) | pub fn lower_equal<R: CubeRuntime>(
  function equal_elem (line 310) | pub fn equal_elem<R: CubeRuntime>(
  function greater_elem (line 318) | pub fn greater_elem<R: CubeRuntime>(
  function lower_elem (line 326) | pub fn lower_elem<R: CubeRuntime>(
  function greater_equal_elem (line 334) | pub fn greater_equal_elem<R: CubeRuntime>(
  function lower_equal_elem (line 342) | pub fn lower_equal_elem<R: CubeRuntime>(
  type PredicateOp (line 353) | pub(crate) trait PredicateOp<F: Float, N: Size>: 'static + Send + Sync {
    method execute (line 355) | fn execute(input: Vector<F, N>) -> Vector<bool, N>;
  type PredicateOpFamily (line 358) | pub(crate) trait PredicateOpFamily: 'static + Send + Sync {
    type Operation (line 366) | type Operation<F: Float, N: Size> = Self;
    type Operation (line 377) | type Operation<F: Float, N: Size> = Self;
  type IsNanOp (line 362) | struct IsNanOp;
    method execute (line 371) | fn execute(input: Vector<F, N>) -> Vector<bool, N> {
  type IsInfOp (line 363) | struct IsInfOp;
    method execute (line 381) | fn execute(input: Vector<F, N>) -> Vector<bool, N> {
  function kernel_predicate (line 387) | pub(crate) fn kernel_predicate<F: Float, Bool: Numeric, N: Size, O: Pred...
  function launch_predicate (line 399) | pub(crate) fn launch_predicate<R: CubeRuntime, O: PredicateOpFamily>(
  function is_nan (line 436) | pub fn is_nan<R: CubeRuntime>(tensor: CubeTensor<R>, dtype_bool: DType) ...
  function is_inf (line 440) | pub fn is_inf<R: CubeRuntime>(tensor: CubeTensor<R>, dtype_bool: DType) ...

FILE: crates/burn-cubecl/src/kernel/contiguous.rs
  function into_contiguous (line 8) | pub fn into_contiguous<R: CubeRuntime>(tensor: CubeTensor<R>) -> CubeTen...
  function into_contiguous_aligned (line 36) | pub fn into_contiguous_aligned<R: CubeRuntime>(tensor: CubeTensor<R>) ->...
  function into_contiguous_quantized (line 63) | fn into_contiguous_quantized<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/conv/backward_data/fallback.rs
  function conv_data_backward_fallback (line 15) | pub(crate) fn conv_data_backward_fallback<R: CubeRuntime, const N_DIM: u...
  function calculate_padding_out (line 92) | fn calculate_padding_out(
  function conv_transpose1d_from_conv_transpose2d (line 110) | fn conv_transpose1d_from_conv_transpose2d<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/conv/backward_data/implicit_gemm/launch.rs
  function dgrad_gemm_simple_sync (line 16) | pub fn dgrad_gemm_simple_sync<R: CubeRuntime, const N: usize>(
  function dgrad_gemm_simple_async (line 39) | pub fn dgrad_gemm_simple_async<R: CubeRuntime, const N: usize>(
  function dgrad_gemm_simple_tma (line 62) | pub fn dgrad_gemm_simple_tma<R: CubeRuntime, const N: usize>(
  function launch_backwards_data (line 88) | pub fn launch_backwards_data<R: CubeRuntime, const N: usize>(

FILE: crates/burn-cubecl/src/kernel/conv/backward_data/tune.rs
  function dgrad_autotune (line 19) | pub fn dgrad_autotune<R: CubeRuntime, const N: usize>(
  function create_wgrad_input (line 78) | pub fn create_wgrad_input<R: CubeRuntime, const N: usize>(
  function create_key (line 93) | fn create_key<R: CubeRuntime, const N: usize>(
  constant MAX_STRIDE_FACTOR (line 154) | const MAX_STRIDE_FACTOR: u32 = 10;
  function stride_align (line 157) | fn stride_align(strides: &[usize], elem: StorageType) -> u8 {
  function pow2_factor (line 170) | fn pow2_factor(axis: usize) -> u8 {

FILE: crates/burn-cubecl/src/kernel/conv/backward_weight/fallback.rs
  function conv_weight_backward_fallback (line 13) | pub fn conv_weight_backward_fallback<R: CubeRuntime, const N_DIM: usize>(
  function conv_weight_grad_no_groups (line 25) | fn conv_weight_grad_no_groups<R: CubeRuntime, const N_DIM: usize>(
  function conv_weight_grad_groups (line 52) | fn conv_weight_grad_groups<R: CubeRuntime, const N_DIM: usize>(

FILE: crates/burn-cubecl/src/kernel/conv/backward_weight/implicit_gemm/launch.rs
  function wgrad_gemm_simple_sync (line 16) | pub(crate) fn wgrad_gemm_simple_sync<R: CubeRuntime, const N: usize>(
  function wgrad_gemm_simple_async (line 39) | pub(crate) fn wgrad_gemm_simple_async<R: CubeRuntime, const N: usize>(
  function wgrad_gemm_simple_tma (line 62) | pub(crate) fn wgrad_gemm_simple_tma<R: CubeRuntime, const N: usize>(
  function launch_backwards_weight (line 88) | pub fn launch_backwards_weight<R: CubeRuntime, const N: usize>(

FILE: crates/burn-cubecl/src/kernel/conv/backward_weight/tune.rs
  function wgrad_autotune (line 19) | pub fn wgrad_autotune<R: CubeRuntime, const N: usize>(
  function create_wgrad_input (line 81) | pub fn create_wgrad_input<R: CubeRuntime, const N: usize>(
  function create_key (line 96) | fn create_key<R: CubeRuntime, const N: usize>(
  constant MAX_STRIDE_FACTOR (line 157) | const MAX_STRIDE_FACTOR: u32 = 10;
  function stride_align (line 160) | fn stride_align(strides: &[usize], elem: StorageType) -> u8 {
  function pow2_factor (line 173) | fn pow2_factor(axis: usize) -> u8 {

FILE: crates/burn-cubecl/src/kernel/conv/base.rs
  type ConvStrategy (line 23) | pub enum ConvStrategy {
  method default (line 35) | fn default() -> Self {
  function conv_forward (line 53) | pub fn conv_forward<R: CubeRuntime, const N: usize>(
  function conv_forward_nhwc (line 75) | pub fn conv_forward_nhwc<R: CubeRuntime, const N: usize>(
  function conv_weight_backward (line 109) | pub fn conv_weight_backward<R: CubeRuntime, const N: usize>(
  function conv_data_backward (line 156) | pub fn conv_data_backward<R: CubeRuntime, const N: usize>(

FILE: crates/burn-cubecl/src/kernel/conv/conv_transpose2d/base.rs
  type ConvTranspose2dStrategy (line 10) | pub enum ConvTranspose2dStrategy {
  method default (line 21) | fn default() -> Self {
  function conv_transpose2d (line 39) | pub fn conv_transpose2d<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/conv/conv_transpose2d/col2im.rs
  function conv_transpose2d_col2im (line 30) | pub fn conv_transpose2d_col2im<R: CubeRuntime>(
  function index (line 135) | pub(crate) fn index<R: CubeRuntime>(tensor: CubeTensor<R>, i: usize) -> ...
  function execute (line 147) | fn execute<R: CubeRuntime>(
  function col2im (line 177) | fn col2im<R: CubeRuntime>(
  type Col2ImArgs (line 228) | struct Col2ImArgs {
  function col2im_kernel (line 244) | fn col2im_kernel<E: Numeric>(

FILE: crates/burn-cubecl/src/kernel/conv/conv_transpose2d/transpose_direct.rs
  type ConvArgs (line 16) | struct ConvArgs {
  function conv_transpose2d_direct_kernel (line 27) | fn conv_transpose2d_direct_kernel<E: Numeric>(
  function conv_transpose2d_direct (line 129) | pub fn conv_transpose2d_direct<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/conv/conv_transpose2d/tune.rs
  function conv_transpose2d_autotune (line 11) | pub fn conv_transpose2d_autotune<R: CubeRuntime>(
  function create_transpose2d_input (line 41) | pub fn create_transpose2d_input<R: CubeRuntime>(
  function create_key (line 61) | fn create_key<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/conv/conv_transpose3d.rs
  type ConvArgs (line 16) | struct ConvArgs {
  function conv_transpose3d_kernel (line 30) | fn conv_transpose3d_kernel<E: Numeric>(
  function conv_transpose3d (line 152) | pub(crate) fn conv_transpose3d<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/conv/deform_conv2d.rs
  type DeformConv2dArgs (line 21) | struct DeformConv2dArgs {
  function deform_im2col_kernel (line 37) | fn deform_im2col_kernel<F: Float>(
  function bilinear_interpolate (line 130) | pub(crate) fn bilinear_interpolate<F: Float>(
  function deform_im2col (line 188) | pub(crate) fn deform_im2col<R: CubeRuntime>(
  function deform_conv2d (line 256) | pub(crate) fn deform_conv2d<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/conv/deform_conv_transpose2d.rs
  function deform_conv2d_backward (line 37) | pub(crate) fn deform_conv2d_backward<R: CubeRuntime>(
  function compute_weight_grad (line 121) | fn compute_weight_grad<R: CubeRuntime>(
  type InputGradients (line 157) | type InputGradients<R> = (CubeTensor<R>, CubeTensor<R>, Option<CubeTenso...
  function backward_gradient_inputs (line 159) | fn backward_gradient_inputs<R: CubeRuntime>(
  function compute_offset_and_mask_gradient (line 223) | fn compute_offset_and_mask_gradient<R: CubeRuntime>(
  type DeformConv2dCol2ImgCoordArgs (line 287) | struct DeformConv2dCol2ImgCoordArgs {
  function deform_col2img_coord_kernel (line 301) | fn deform_col2img_coord_kernel<F: Float>(
  function get_coordinate_weight (line 414) | fn get_coordinate_weight<F: Float>(
  function compute_input_grad (line 469) | fn compute_input_grad<R: CubeRuntime>(
  type DeformConv2dCol2ImgArgs (line 553) | struct DeformConv2dCol2ImgArgs {
  function deform_col2img_kernel (line 566) | fn deform_col2img_kernel<F: Float, FP: Float, FAdd: FloatAtomicAddFamily>(
  type ProxyType (line 655) | type ProxyType<FADF, FP> = <<FADF as FloatAtomicAddFamily>::Op<FP> as Fl...
  type FloatAtomicAddFamily (line 658) | trait FloatAtomicAddFamily: Send + Sync + 'static {
    type Op (line 681) | type Op<ProxyType: Float> = IntrinsicFloatAtomicAdd<ProxyType>;
    type Op (line 685) | type Op<ProxyType: Float> = Self;
  type FloatAtomicAdd (line 663) | trait FloatAtomicAdd: Send + Sync + 'static {
    method float_atomic_add (line 666) | fn float_atomic_add<F: Float>(ptr: &mut Atomic<Self::ProxyType>, value...
    type ProxyType (line 690) | type ProxyType = FAdd;
    method float_atomic_add (line 692) | fn float_atomic_add<F: Float>(ptr: &mut Atomic<FAdd>, value: F) {
    type ProxyType (line 700) | type ProxyType = u32;
    method float_atomic_add (line 702) | fn float_atomic_add<F: Float>(ptr: &mut Atomic<Self::ProxyType>, value...
  type IntrinsicFloatAtomicAdd (line 670) | struct IntrinsicFloatAtomicAdd<F: Float> {
  type CASFloatAtomicAdd (line 676) | struct CASFloatAtomicAdd;
  type IntrinsicFloatAtomicAddFamily (line 678) | struct IntrinsicFloatAtomicAddFamily;

FILE: crates/burn-cubecl/src/kernel/conv/direct.rs
  type ConvParam (line 20) | pub(crate) struct ConvParam {
  type Conv2dArgs (line 27) | struct Conv2dArgs {
  function direct_conv2d_kernel (line 34) | fn direct_conv2d_kernel<E: Numeric, NIn: Size, NOut: Size>(
  type LoopParams (line 112) | struct LoopParams {
  function kernel_loop (line 125) | fn kernel_loop<E: Numeric, NIn: Size, NOut: Size>(
  function kernel_loop_inner (line 180) | fn kernel_loop_inner<E: Numeric, NIn: Size, NOut: Size>(
  function conv_direct (line 222) | pub fn conv_direct<R: CubeRuntime, const N: usize>(

FILE: crates/burn-cubecl/src/kernel/conv/forward/implicit_gemm/launch.rs
  function conv_gemm_simple_sync (line 21) | pub fn conv_gemm_simple_sync<R: CubeRuntime, const N: usize>(
  function conv_gemm_simple_async (line 44) | pub fn conv_gemm_simple_async<R: CubeRuntime, const N: usize>(
  function conv_gemm_simple_tma (line 74) | pub fn conv_gemm_simple_tma<R: CubeRuntime, const N: usize>(
  function launch_convolution_forward (line 100) | pub fn launch_convolution_forward<R: CubeRuntime, const N: usize>(

FILE: crates/burn-cubecl/src/kernel/conv/forward/tune.rs
  function conv_autotune (line 15) | pub fn conv_autotune<R: CubeRuntime, const N: usize>(
  function create_conv_input (line 75) | pub fn create_conv_input<R: CubeRuntime, const N: usize>(
  function create_key (line 95) | fn create_key<R: CubeRuntime, const N: usize>(
  constant MAX_STRIDE_FACTOR (line 156) | const MAX_STRIDE_FACTOR: u32 = 10;
  function stride_align (line 159) | fn stride_align(strides: &[usize], elem: StorageType) -> u8 {
  function pow2_factor (line 172) | fn pow2_factor(axis: usize) -> u8 {

FILE: crates/burn-cubecl/src/kernel/conv/im2col.rs
  function batches_per_run (line 25) | pub(crate) fn batches_per_run(
  function batches_per_run (line 51) | pub(crate) fn batches_per_run(
  function conv_im2col_1x1 (line 59) | pub fn conv_im2col_1x1<R: CubeRuntime, const N: usize>(
  function reshape_input (line 135) | fn reshape_input<R: CubeRuntime>(input: CubeTensor<R>) -> CubeTensor<R> {
  function is_spatial_contiguous (line 159) | fn is_spatial_contiguous(shape: &[usize], strides: &[usize]) -> bool {
  function from_handle (line 176) | fn from_handle<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/conv/tune_key.rs
  type ConvAutotuneKey (line 7) | pub struct ConvAutotuneKey {
  type ConvTranspose2dAutotuneKey (line 31) | pub struct ConvTranspose2dAutotuneKey {

FILE: crates/burn-cubecl/src/kernel/cross.rs
  function cross_kernel (line 11) | fn cross_kernel<E: Float>(
  function cross (line 44) | pub(crate) fn cross<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/grid_sample/base.rs
  function grid_sample (line 9) | pub fn grid_sample<R: CubeRuntime>(
  type PaddingMode (line 25) | pub enum PaddingMode {
    method from (line 35) | fn from(mode: GridSamplePaddingMode) -> Self {
  function fetch_value (line 46) | pub(crate) fn fetch_value<F: Float>(
  function fetch_with_zeros (line 68) | pub(crate) fn fetch_with_zeros<F: Float>(
  function fetch_with_border (line 87) | pub(crate) fn fetch_with_border<F: Float>(
  function fetch_with_reflection (line 106) | pub(crate) fn fetch_with_reflection<F: Float>(
  function reflect_coord_bounded (line 125) | fn reflect_coord_bounded(idx: i32, size: i32) -> usize {
  function reflect_coord (line 139) | pub(crate) fn reflect_coord<F: Float>(coord: F, size: u32, #[comptime] a...
  function reflect_float_impl (line 150) | fn reflect_float_impl<F: Float>(coord: F, min_val: F, max_val: F) -> F {

FILE: crates/burn-cubecl/src/kernel/grid_sample/bilinear.rs
  function grid_sample_bilinear_kernel (line 18) | fn grid_sample_bilinear_kernel<F: Float>(
  function grid_sample_bilinear_launch (line 129) | pub(crate) fn grid_sample_bilinear_launch<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/index/flip.rs
  function flip_kernel (line 15) | fn flip_kernel<E: Numeric, Bool: Int>(
  function flip (line 48) | pub(crate) fn flip<R: CubeRuntime>(
  function flip_on_output (line 62) | pub(crate) fn flip_on_output<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/index/gather.rs
  function gather_kernel (line 14) | fn gather_kernel<T: Numeric, I: Numeric>(
  function gather (line 39) | pub(crate) fn gather<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/index/repeat_dim.rs
  function repeat_dim_kernel (line 10) | fn repeat_dim_kernel<E: Numeric>(
  function repeat_dim (line 47) | pub(crate) fn repeat_dim<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/index/scatter.rs
  function scatter_kernel (line 13) | fn scatter_kernel<T: Numeric, I: Int, Op: BinaryOpFamily>(
  function scatter (line 72) | pub(crate) fn scatter<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/index/select.rs
  function select_kernel (line 8) | fn select_kernel<T: Numeric, I: Numeric>(
  function select (line 43) | pub(crate) fn select<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/index/select_assign.rs
  function select_assign_kernel (line 10) | fn select_assign_kernel<F: Numeric, I: Numeric, Op: BinaryOpFamily>(
  function select_assign (line 58) | pub(crate) fn select_assign<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/index/slice.rs
  function slice (line 17) | pub fn slice<R: CubeRuntime>(tensor: CubeTensor<R>, indices: &[Range<usi...
  function slice_kernel (line 59) | fn slice_kernel<E: Numeric>(
  function slice_on_output (line 91) | pub(crate) fn slice_on_output<R: CubeRuntime>(
  function slice_with_steps_kernel (line 128) | fn slice_with_steps_kernel<E: Numeric>(
  function slice_with_steps (line 174) | pub fn slice_with_steps<R: CubeRuntime>(tensor: CubeTensor<R>, slices: &...
  function unwrap (line 246) | fn unwrap(value: u32) -> comptime_type!(u32) {

FILE: crates/burn-cubecl/src/kernel/index/slice_assign.rs
  function slice_assign_kernel (line 13) | fn slice_assign_kernel<E: Numeric, N: Size>(
  function slice_assign_with_steps_kernel (line 49) | fn slice_assign_with_steps_kernel<E: Numeric>(
  function slice_assign (line 98) | pub(crate) fn slice_assign<R: CubeRuntime>(
  function slice_assign_with_steps (line 193) | pub(crate) fn slice_assign_with_steps<R: CubeRuntime>(
  function strides_compatible (line 247) | fn strides_compatible(strides: &[usize], vec: usize) -> bool {
  function unwrap (line 256) | fn unwrap(value: u32) -> comptime_type!(u32) {

FILE: crates/burn-cubecl/src/kernel/interpolate/base.rs
  function interpolate (line 21) | pub fn interpolate<R: CubeRuntime>(
  function interpolate_backward (line 53) | pub fn interpolate_backward<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/interpolate/bicubic.rs
  function interpolate_bicubic_kernel (line 15) | fn interpolate_bicubic_kernel<F: Float, N: Size>(
  function cubic_interp_1d (line 127) | fn cubic_interp_1d<F: Float, N: Size>(
  function cubic_convolution_1 (line 145) | fn cubic_convolution_1<F: Float, N: Size>(x: Vector<F, N>, a: Vector<F, ...
  function cubic_convolution_2 (line 152) | fn cubic_convolution_2<F: Float, N: Size>(x: Vector<F, N>, a: Vector<F, ...
  function float (line 162) | fn float<F: Float, N: Size>(#[comptime] v: f32) -> Vector<F, N> {
  function interpolate_bicubic_launch (line 166) | pub(crate) fn interpolate_bicubic_launch<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/interpolate/bilinear.rs
  function interpolate_bilinear_kernel (line 18) | fn interpolate_bilinear_kernel<F: Float, N: Size>(
  function interpolate_bilinear_launch (line 124) | pub(crate) fn interpolate_bilinear_launch<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/interpolate/lanczos3.rs
  function interpolate_lanczos3_kernel (line 18) | fn interpolate_lanczos3_kernel<F: Float, N: Size>(
  function lanczos3_weight (line 106) | fn lanczos3_weight(x: f32) -> f32 {
  function interpolate_lanczos3_launch (line 120) | pub(crate) fn interpolate_lanczos3_launch<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/interpolate/nearest.rs
  function interpolate_nearest_kernel (line 15) | fn interpolate_nearest_kernel<F: Float, N: Size>(
  function interpolate_nearest_launch (line 49) | pub(crate) fn interpolate_nearest_launch<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/interpolate/nearest_backward.rs
  function interpolate_nearest_backward_kernel (line 18) | fn interpolate_nearest_backward_kernel<F: Float, N: Size>(
  function start_index (line 62) | fn start_index<F: Float>(input_index: usize, output_size: usize, input_s...
  function end_index (line 70) | fn end_index<F: Float>(input_index: usize, output_size: usize, input_siz...
  function interpolate_nearest_backward_launch (line 78) | pub(crate) fn interpolate_nearest_backward_launch<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/mask/base.rs
  function mask_fill_auto (line 8) | pub(crate) fn mask_fill_auto<R: CubeRuntime>(
  function mask_where_auto (line 24) | pub(crate) fn mask_where_auto<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/mask/mask_fill.rs
  function mask_fill_kernel (line 12) | fn mask_fill_kernel<T: Numeric, B: Int, N: Size>(
  type MaskFillStrategy (line 36) | pub enum MaskFillStrategy {
  function mask_fill (line 44) | pub fn mask_fill<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/mask/mask_where.rs
  function mask_where_kernel (line 12) | fn mask_where_kernel<T: Numeric, B: Int, N: Size>(
  type MaskWhereStrategy (line 33) | pub enum MaskWhereStrategy {
  function mask_where (line 43) | pub fn mask_where<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/matmul/base.rs
  type MatmulStrategy (line 14) | pub enum MatmulStrategy {
  method default (line 23) | fn default() -> Self {
  function matmul (line 34) | pub fn matmul<R: CubeRuntime>(
  function launch_matmul_naive (line 52) | pub(crate) fn launch_matmul_naive<R: CubeRuntime>(
  function launch_matmul (line 78) | pub(crate) fn launch_matmul<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/matmul/tune/base.rs
  function matmul_input_gen (line 18) | fn matmul_input_gen<R: CubeRuntime>(
  function matmul_autotune (line 28) | pub fn matmul_autotune<R: CubeRuntime>(
  function create_key (line 392) | fn create_key<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/matmul/utils.rs
  function init_matmul_output (line 5) | pub fn init_matmul_output<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/pool/adaptive_avg_pool2d.rs
  function adaptive_avg_pool2d_direct (line 22) | fn adaptive_avg_pool2d_direct<E: Numeric, N: Size>(
  function start_index (line 68) | fn start_index(output_size_index: usize, output_size: usize, input_size:...
  function end_index (line 73) | fn end_index(output_size_index: usize, output_size: usize, input_size: u...
  function adaptive_avg_pool2d (line 84) | pub(crate) fn adaptive_avg_pool2d<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/pool/adaptive_avg_pool2d_backward.rs
  function adaptive_avg_pool2d_backward_direct (line 22) | fn adaptive_avg_pool2d_backward_direct<E: Numeric, N: Size>(
  function start_index (line 75) | fn start_index(output_size_index: usize, output_size: usize, input_size:...
  function end_index (line 80) | fn end_index(output_size_index: usize, output_size: usize, input_size: u...
  function adaptive_avg_pool2d_backward (line 91) | pub(crate) fn adaptive_avg_pool2d_backward<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/pool/avg_pool2d.rs
  type AvgPoolStrategy (line 20) | struct AvgPoolStrategy;
    type Accumulator (line 39) | type Accumulator = (Vector<T, N>, u32);
    type Config (line 40) | type Config = AvgPoolStrategyConfig;
    type Indices (line 41) | type Indices = ();
    method initialize (line 43) | fn initialize(#[comptime] _config: &Self::Config) -> Self::Accumulator {
    method accumulate (line 52) | fn accumulate(
    method count_position (line 68) | fn count_position(
    method store (line 82) | fn store(
  type Indices (line 23) | type Indices<N: Size> = ();
  type Config (line 24) | type Config = AvgPoolStrategyConfig;
  type Pool2d (line 25) | type Pool2d<T: Numeric, N: Size> = Self;
  type AvgPoolStrategyConfig (line 29) | pub struct AvgPoolStrategyConfig {
  function avg_pool2d (line 94) | pub(crate) fn avg_pool2d<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/pool/avg_pool2d_backward.rs
  type PoolBackwardArgs (line 21) | pub(crate) struct PoolBackwardArgs {
  function avg_pool2d_backward_kernel (line 31) | fn avg_pool2d_backward_kernel<E: Numeric, N: Size>(
  function loop_ranges (line 111) | fn loop_ranges(
  function avg_pool2d_backward (line 131) | pub(crate) fn avg_pool2d_backward<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/pool/max_pool2d.rs
  type MaxPoolStrategy (line 21) | struct MaxPoolStrategy;
    type Accumulator (line 38) | type Accumulator = Vector<T, N>;
    type Config (line 39) | type Config = ();
    type Indices (line 40) | type Indices = ();
    method initialize (line 42) | fn initialize(#[comptime] _config: &Self::Config) -> Self::Accumulator {
    method accumulate (line 46) | fn accumulate(
    method count_position (line 55) | fn count_position(
    method store (line 63) | fn store(
  type MaxPoolWithIndicesStrategy (line 22) | struct MaxPoolWithIndicesStrategy;
    type Accumulator (line 76) | type Accumulator = (Vector<T, N>, Vector<i32, N>);
    type Config (line 77) | type Config = ();
    type Indices (line 78) | type Indices = View<Vector<i32, N>, Position, ReadWrite>;
    method initialize (line 80) | fn initialize(#[comptime] _config: &Self::Config) -> Self::Accumulator {
    method accumulate (line 86) | fn accumulate(
    method count_position (line 97) | fn count_position(
    method store (line 105) | fn store(
  type Indices (line 25) | type Indices<N: Size> = ();
  type Config (line 26) | type Config = ();
  type Pool2d (line 27) | type Pool2d<T: Numeric, N: Size> = Self;
  type Indices (line 31) | type Indices<N: Size> = View<Vector<i32, N>, Position, ReadWrite>;
  type Config (line 32) | type Config = ();
  type Pool2d (line 33) | type Pool2d<T: Numeric, N: Size> = Self;
  function max_pool2d (line 117) | pub(crate) fn max_pool2d<R: CubeRuntime>(
  function max_pool2d_with_indices (line 182) | pub(crate) fn max_pool2d_with_indices<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/pool/max_pool2d_backward.rs
  function max_pool2d_with_indices_backward_kernel (line 18) | fn max_pool2d_with_indices_backward_kernel<E: Numeric, I: Int, N: Size>(
  function loop_ranges (line 82) | fn loop_ranges(
  function max_pool2d_with_indices_backward (line 103) | pub(crate) fn max_pool2d_with_indices_backward<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/pool/pool2d.rs
  type Pool2dDirectStrategyFamily (line 16) | pub trait Pool2dDirectStrategyFamily: Send + Sync + 'static {
  type Position (line 22) | pub(super) type Position = (usize, usize, usize, usize);
  type Pool2dDirectStrategy (line 25) | pub(crate) trait Pool2dDirectStrategy<T: Numeric, N: Size>: Send + Sync ...
    method initialize (line 31) | fn initialize(#[comptime] config: &Self::Config) -> Self::Accumulator;
    method accumulate (line 33) | fn accumulate(
    method count_position (line 43) | fn count_position(
    method store (line 50) | fn store(
  type Pool2dDirectArgs (line 60) | pub struct Pool2dDirectArgs {
  function pool2d_direct (line 70) | pub fn pool2d_direct<E: Numeric, N: Size, S: Pool2dDirectStrategyFamily>(
  function view4d (line 133) | pub(super) fn view4d<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/prng/bernoulli.rs
  function random_bernoulli (line 5) | pub fn random_bernoulli<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/prng/normal.rs
  function random_normal (line 5) | pub fn random_normal<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/prng/uniform.rs
  function random_uniform (line 5) | pub fn random_uniform<R: CubeRuntime>(
  function random_like_uniform (line 29) | pub fn random_like_uniform<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/quantization/dequantize.rs
  function dequantize (line 6) | pub fn dequantize<R>(tensor: CubeTensor<R>, dtype: DType) -> CubeTensor<R>

FILE: crates/burn-cubecl/src/kernel/quantization/quantize.rs
  function quantize (line 6) | pub fn quantize<R>(

FILE: crates/burn-cubecl/src/kernel/reduce/base.rs
  type SumAutotuneKey (line 22) | pub struct SumAutotuneKey {
  function supports_atomic_add (line 31) | fn supports_atomic_add<R: CubeRuntime>(client: &ComputeClient<R>, dtype:...
  function sum_fallback (line 39) | pub fn sum_fallback<R: CubeRuntime>(
  function sum (line 58) | pub fn sum<Run: CubeRuntime>(
  type SumStrategy (line 89) | pub enum SumStrategy {
  method default (line 101) | fn default() -> Self {
  function reduce (line 116) | pub fn reduce<Run: CubeRuntime>(
  function argsort (line 133) | fn argsort(shape: &[usize]) -> Vec<usize> {
  function reduce_dim (line 146) | pub fn reduce_dim<Run: CubeRuntime>(
  function init_reduce_output (line 206) | pub fn init_reduce_output<Run: CubeRuntime>(
  type KernelReduceStrategy (line 225) | pub enum KernelReduceStrategy {
  method default (line 237) | fn default() -> Self {

FILE: crates/burn-cubecl/src/kernel/reduce/tune.rs
  function autotune_reduce (line 17) | pub fn autotune_reduce<R: CubeRuntime>(
  function create_key (line 155) | pub(crate) fn create_key<Run: CubeRuntime>(
  function reduce_input_gen (line 183) | pub(crate) fn reduce_input_gen<Run: CubeRuntime>(
  function autotune_sum (line 203) | pub fn autotune_sum<R: CubeRuntime>(
  function create_key_sum (line 231) | pub(crate) fn create_key_sum<Run: CubeRuntime>(input: &CubeTensor<Run>) ...
  method generate (line 237) | pub(crate) fn generate<Run: CubeRuntime>(input: &CubeTensor<Run>) -> Self {
  function sum_input_gen (line 249) | pub(crate) fn sum_input_gen<Run: CubeRuntime>(
  function sum_one_shot (line 256) | pub(crate) fn sum_one_shot<Run: CubeRuntime, const C: u32>(
  function sum_chained (line 276) | pub(crate) fn sum_chained<Run: CubeRuntime>(

FILE: crates/burn-cubecl/src/kernel/unary_float.rs
  type FloatUnaryOpFamily (line 10) | pub(crate) trait FloatUnaryOpFamily: 'static + Send + Sync {
    type Options (line 191) | type Options = BasicFloatUnaryOptions;
    type Unary (line 192) | type Unary<F: Float, N: Size> = Self;
  type FloatUnaryOp (line 16) | pub(crate) trait FloatUnaryOp<F: Float, N: Size>: 'static + Send + Sync {
    method execute (line 19) | fn execute(input: Vector<F, N>, options: &Self::Options) -> Vector<F, N>;
  function unary_float (line 23) | pub(crate) fn unary_float<F: Float, N: Size, O: FloatUnaryOpFamily>(
  function launch_unary_float (line 36) | pub(crate) fn launch_unary_float<R, O, Args>(tensor: CubeTensor<R>, args...
  function launch (line 101) | pub(crate) fn launch<R, Args>(tensor: CubeTensor<R>, args: Args) -> Cube...
  type BasicFloatUnaryKind (line 112) | pub enum BasicFloatUnaryKind {
  type BasicFloatUnaryOptions (line 140) | struct BasicFloatUnaryOptions {
  type BasicFloatUnary (line 144) | struct BasicFloatUnary;
    type Options (line 148) | type Options = BasicFloatUnaryOptions;
    method execute (line 150) | fn execute(input: Vector<F, N>, options: &Self::Options) -> Vector<F, ...

FILE: crates/burn-cubecl/src/kernel/unary_int.rs
  type IntUnaryOpFamily (line 10) | pub(crate) trait IntUnaryOpFamily: 'static + Send + Sync {
    type Options (line 143) | type Options = BasicIntUnaryOptions;
    type Unary (line 144) | type Unary<I: Int, N: Size> = Self;
  type IntUnaryOp (line 16) | pub(crate) trait IntUnaryOp<I: Scalar, N: Size>: 'static + Send + Sync {
    method execute (line 19) | fn execute(input: Vector<I, N>, options: &Self::Options) -> Vector<I, N>;
  function unary_int (line 23) | pub(crate) fn unary_int<I: Int, N: Size, O: IntUnaryOpFamily>(
  function launch_unary_int (line 36) | pub(crate) fn launch_unary_int<R, O, Args>(tensor: CubeTensor<R>, args: ...
  function launch (line 97) | pub(crate) fn launch<R, Args>(tensor: CubeTensor<R>, args: Args) -> Cube...
  type BasicIntUnaryKind (line 108) | pub enum BasicIntUnaryKind {
  type BasicIntUnaryOptions (line 114) | struct BasicIntUnaryOptions {
  type BasicIntUnary (line 118) | struct BasicIntUnary;
    type Options (line 122) | type Options = BasicIntUnaryOptions;
    method execute (line 124) | fn execute(input: Vector<I, N>, options: &Self::Options) -> Vector<I, ...

FILE: crates/burn-cubecl/src/kernel/unary_numeric.rs
  type NumericUnaryOpFamily (line 10) | pub(crate) trait NumericUnaryOpFamily: 'static + Send + Sync {
  type NumericUnaryOp (line 16) | pub(crate) trait NumericUnaryOp<T: Scalar, N: Size>: 'static + Send + Sy...
    method execute (line 19) | fn execute(input: Vector<T, N>, options: &Self::Options) -> Vector<T, N>;
  function unary_numeric (line 23) | pub(crate) fn unary_numeric<T: Numeric, N: Size, O: NumericUnaryOpFamily>(
  function launch_unary_numeric (line 36) | pub(crate) fn launch_unary_numeric<R, O, Args>(tensor: CubeTensor<R>, ar...

FILE: crates/burn-cubecl/src/kernel/utils.rs
  function shape_divmod (line 14) | pub fn shape_divmod<R: CubeRuntime>(tensor: &CubeTensor<R>) -> SequenceA...
  function linear_layout (line 22) | pub fn linear_layout<R: CubeRuntime>(
  function split_dim (line 35) | pub fn split_dim<R: CubeRuntime>(
  function broadcast_shape (line 51) | pub fn broadcast_shape<R: CubeRuntime>(tensors: &[&CubeTensor<R>]) -> Sh...
  function broadcast_strides (line 73) | pub fn broadcast_strides<R: CubeRuntime>(
  function decompose_linear (line 97) | pub(crate) fn decompose_linear<I: FastDivmodInt>(
  type RequiredAddrType (line 116) | pub(crate) trait RequiredAddrType {
    method required_address_type (line 117) | fn required_address_type(&self) -> AddressType;
    method required_address_type (line 121) | fn required_address_type(&self) -> AddressType {
    method required_address_type (line 126) | fn required_address_type(&self) -> AddressType {

FILE: crates/burn-cubecl/src/lib.rs
  type CubeRuntime (line 43) | pub trait CubeRuntime: Runtime<Device = Self::CubeDevice, Server = Self:...

FILE: crates/burn-cubecl/src/ops/base.rs
  function from_data (line 14) | pub(crate) fn from_data<R: CubeRuntime>(data: TensorData, device: &R::De...
  function into_data (line 27) | pub(crate) async fn into_data<R: CubeRuntime>(
  function into_data_sync (line 53) | pub fn into_data_sync<R: CubeRuntime>(tensor: CubeTensor<R>) -> TensorDa...
  function to_device (line 61) | pub(crate) fn to_device<R: CubeRuntime>(
  function empty (line 74) | pub(crate) fn empty<R: CubeRuntime>(
  function swap_dims (line 91) | pub(crate) fn swap_dims<R: CubeRuntime>(
  function permute (line 134) | pub fn permute<R: CubeRuntime>(mut tensor: CubeTensor<R>, axes: &[usize]...
  function permute_nchw_to_nhwc (line 175) | pub fn permute_nchw_to_nhwc<R: CubeRuntime>(tensor: CubeTensor<R>) -> Cu...
  function permute_nchw_to_nhwc_shape (line 187) | pub fn permute_nchw_to_nhwc_shape(shape: Shape) -> Shape {
  function permute_nhwc_to_nchw (line 199) | pub fn permute_nhwc_to_nchw<R: CubeRuntime>(tensor: CubeTensor<R>) -> Cu...
  function permute_nhwc_to_nchw_shape (line 211) | pub fn permute_nhwc_to_nchw_shape(shape: Shape) -> Shape {
  function expand (line 222) | pub(crate) fn expand<R: CubeRuntime>(tensor: CubeTensor<R>, target_shape...
  function reshape (line 280) | pub fn reshape<R: CubeRuntime>(mut tensor: CubeTensor<R>, shape: Shape) ...
  function q_reshape (line 310) | pub fn q_reshape<R: CubeRuntime>(mut tensor: CubeTensor<R>, shape: Shape...
  function max_vector_size (line 365) | pub(crate) fn max_vector_size<R: CubeRuntime>(tensor: &CubeTensor<R>) ->...
  function max_vector_size_many (line 374) | pub(crate) fn max_vector_size_many<R: CubeRuntime>(
  function unfold (line 414) | pub fn unfold<R: CubeRuntime>(

FILE: crates/burn-cubecl/src/ops/bool_tensor.rs
  function bool_empty (line 25) | fn bool_empty(shape: Shape, device: &Device<Self>) -> BoolTensor<Self> {
  function bool_zeros (line 29) | fn bool_zeros(shape: Shape, device: &Device<Self>) -> BoolTensor<Self> {
  function bool_ones (line 33) | fn bool_ones(shape: Shape, device: &Device<Self>) -> BoolTensor<Self> {
  function bool_into_data (line 37) | async fn bool_into_data(tensor: BoolTensor<Self>) -> Result<TensorData, ...
  function bool_from_data (line 41) | fn bool_from_data(data: TensorData, device: &Device<Self>) -> BoolTensor...
  function bool_into_int (line 55) | fn bool_into_int(tensor: BoolTensor<Self>) -> IntTensor<Self> {
  function bool_device (line 59) | fn bool_device(tensor: &BoolTensor<Self>) -> Device<Self> {
  function bool_to_device (line 63) | fn bool_to_device(tensor: BoolTensor<Self>, device: &Device<Self>) -> Bo...
  function bool_reshape (line 67) | fn bool_reshape(tensor: BoolTensor<Self>, shape: Shape) -> BoolTensor<Se...
  function bool_slice (line 71) | fn bool_slice(tensor: BoolTensor<Self>, slices: &[Slice]) -> BoolTensor<...
  function bool_slice_assign (line 90) | fn bool_slice_assign(
  function bool_equal (line 98) | fn bool_equal(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTenso...
  function bool_not (line 102) | fn bool_not(tensor: BoolTensor<Self>) -> BoolTensor<Self> {
  function bool_and (line 110) | fn bool_and(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTensor<...
  function bool_or (line 114) | fn bool_or(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTensor<S...
  function bool_into_float (line 118) | fn bool_into_float(tensor: BoolTensor<Self>) -> FloatTensor<Self> {
  function bool_swap_dims (line 122) | fn bool_swap_dims(mut tensor: BoolTensor<Self>, dim1: usize, dim2: usize...
  function bool_repeat_dim (line 128) | fn bool_repeat_dim(tensor: BoolTensor<Self>, dim: usize, times: usize) -...
  function bool_permute (line 132) | fn bool_permute(tensor: BoolTensor<Self>, axes: &[usize]) -> BoolTensor<...
  function bool_expand (line 136) | fn bool_expand(tensor: BoolTensor<Self>, shape: Shape) -> BoolTensor<Sel...
  function bool_select (line 140) | fn bool_select(
  function bool_select_or (line 148) | fn bool_select_or(
  function bool_flip (line 157) | fn bool_flip(tensor: BoolTensor<Self>, axes: &[usize]) -> BoolTensor<Sel...
  function bool_unfold (line 161) | fn bool_unfold(
  function bool_mask_where (line 170) | fn bool_mask_where(
  function bool_mask_fill (line 178) | fn bool_mask_fill(
  function bool_gather (line 187) | fn bool_gather(
  function bool_scatter_or (line 195) | fn bool_scatter_or(
  function bool_equal_elem (line 204) | fn bool_equal_elem(lhs: BoolTensor<Self>, rhs: Scalar) -> BoolTensor<Sel...

FILE: crates/burn-cubecl/src/ops/int_tensor.rs
  function int_empty (line 36) | fn int_empty(shape: Shape, device: &Device<Self>, dtype: IntDType) -> In...
  function int_into_data (line 41) | async fn int_into_data(tensor: IntTensor<Self>) -> Result<TensorData, Ex...
  function int_from_data (line 45) | fn int_from_data(data: TensorData, device: &Device<Self>) -> IntTensor<S...
  function int_device (line 59) | fn int_device(tensor: &IntTensor<Self>) -> Device<Self> {
  function int_to_device (line 63) | fn int_to_device(tensor: IntTensor<Self>, device: &Device<Self>) -> IntT...
  function int_reshape (line 67) | fn int_reshape(tensor: IntTensor<Self>, shape: Shape) -> IntTensor<Self> {
  function int_slice (line 71) | fn int_slice(tensor: IntTensor<Self>, slices: &[Slice]) -> IntTensor<Sel...
  function int_slice_assign (line 90) | fn int_slice_assign(
  function int_matmul (line 98) | fn int_matmul(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  function int_mask_where (line 103) | fn int_mask_where(
  function int_mask_fill (line 111) | fn int_mask_fill(
  function int_gather (line 125) | fn int_gather(
  function int_scatter_add (line 133) | fn int_scatter_add(
  function int_select (line 142) | fn int_select(
  function int_select_add (line 150) | fn int_select_add(
  function int_equal (line 159) | fn int_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor<S...
  function int_equal_elem (line 163) | fn int_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Self> {
  function int_greater (line 168) | fn int_greater(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor...
  function int_greater_elem (line 172) | fn int_greater_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Sel...
  function int_greater_equal (line 177) | fn int_greater_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> Bool...
  function int_greater_equal_elem (line 181) | fn int_greater_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTens...
  function int_lower (line 186) | fn int_lower(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor<S...
  function int_lower_elem (line 190) | fn int_lower_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Self> {
  function int_lower_equal (line 195) | fn int_lower_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTe...
  function int_lower_equal_elem (line 199) | fn int_lower_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor...
  function int_add (line 204) | fn int_add(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_add_scalar (line 208) | fn int_add_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_sub (line 213) | fn int_sub(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_sub_scalar (line 217) | fn int_sub_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_mul (line 222) | fn int_mul(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_mul_scalar (line 226) | fn int_mul_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_div (line 231) | fn int_div(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_div_scalar (line 235) | fn int_div_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_remainder (line 240) | fn int_remainder(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTenso...
  function int_remainder_scalar (line 244) | fn int_remainder_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<...
  function int_zeros (line 249) | fn int_zeros(shape: Shape, device: &Device<Self>, dtype: IntDType) -> In...
  function int_ones (line 254) | fn int_ones(shape: Shape, device: &Device<Self>, dtype: IntDType) -> Int...
  function int_full (line 259) | fn int_full(
  function int_sum (line 276) | fn int_sum(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_sum_dim (line 280) | fn int_sum_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_prod (line 291) | fn int_prod(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_prod_dim (line 301) | fn int_prod_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_max (line 312) | fn int_max(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_max_dim (line 316) | fn int_max_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_max_abs (line 327) | fn int_max_abs(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_max_abs_dim (line 337) | fn int_max_abs_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Sel...
  function int_min (line 348) | fn int_min(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_min_dim (line 352) | fn int_min_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_mean_dim (line 363) | fn int_mean_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cumsum (line 374) | fn int_cumsum(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cumprod (line 378) | fn int_cumprod(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cummin (line 382) | fn int_cummin(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cummax (line 386) | fn int_cummax(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_argmax (line 390) | fn int_argmax(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_argmin (line 402) | fn int_argmin(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_clamp (line 414) | fn int_clamp(tensor: IntTensor<Self>, min: Scalar, max: Scalar) -> IntTe...
  function int_abs (line 423) | fn int_abs(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_sign (line 443) | fn int_sign(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_into_float (line 447) | fn int_into_float(tensor: IntTensor<Self>) -> FloatTensor<Self> {
  function int_swap_dims (line 451) | fn int_swap_dims(mut tensor: IntTensor<Self>, dim1: usize, dim2: usize) ...
  function int_repeat_dim (line 457) | fn int_repeat_dim(tensor: IntTensor<Self>, dim: usize, times: usize) -> ...
  function int_random (line 461) | fn int_random(
  function int_permute (line 479) | fn int_permute(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Sel...
  function int_expand (line 483) | fn int_expand(tensor: IntTensor<Self>, shape: Shape) -> IntTensor<Self> {
  function int_flip (line 487) | fn int_flip(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Self> {
  function bitwise_and (line 491) | fn bitwise_and(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  function bitwise_and_scalar (line 495) | fn bitwise_and_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  function bitwise_or (line 500) | fn bitwise_or(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  function bitwise_or_scalar (line 504) | fn bitwise_or_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Sel...
  function bitwise_xor (line 509) | fn bitwise_xor(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  function bitwise_xor_scalar (line 513) | fn bitwise_xor_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  function bitwise_not (line 518) | fn bitwise_not(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function bitwise_left_shift (line 522) | fn bitwise_left_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> Int...
  function bitwise_left_shift_scalar (line 526) | fn bitwise_left_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTe...
  function bitwise_right_shift (line 531) | fn bitwise_right_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> In...
  function bitwise_right_shift_scalar (line 535) | fn bitwise_right_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntT...
  function int_cast (line 540) | fn int_cast(tensor: IntTensor<Self>, dtype: IntDType) -> IntTensor<Self> {
  function int_unfold (line 544) | fn int_unfold(

FILE: crates/burn-cubecl/src/ops/module.rs
  function conv1d (line 22) | fn conv1d(
  function conv1d_x_backward (line 31) | fn conv1d_x_backward(
  function conv1d_weight_backward (line 47) | fn conv1d_weight_backward(
  function conv2d (line 63) | fn conv2d(
  function conv2d_x_backward (line 72) | fn conv2d_x_backward(
  function conv2d_weight_backward (line 88) | fn conv2d_weight_backward(
  function deform_conv2d (line 104) | fn deform_conv2d(
  function deform_conv2d_backward (line 115) | fn deform_conv2d_backward(
  function conv3d (line 137) | fn conv3d(
  function conv3d_x_backward (line 146) | fn conv3d_x_backward(
  function conv3d_weight_backward (line 162) | fn conv3d_weight_backward(
  function conv_transpose2d (line 178) | fn conv_transpose2d(
  function conv_transpose3d (line 188) | fn conv_transpose3d(
  function avg_pool2d (line 197) | fn avg_pool2d(
  function avg_pool2d_backward (line 215) | fn avg_pool2d_backward(
  function max_pool2d (line 235) | fn max_pool2d(
  function max_pool2d_with_indices (line 246) | fn max_pool2d_with_indices(
  function max_pool2d_with_indices_backward (line 267) | fn max_pool2d_with_indices_backward(
  function adaptive_avg_pool2d (line 289) | fn adaptive_avg_pool2d(x: FloatTensor<Self>, output_size: [usize; 2]) ->...
  function adaptive_avg_pool2d_backward (line 293) | fn adaptive_avg_pool2d_backward(
  function interpolate (line 300) | fn interpolate(
  function interpolate_backward (line 308) | fn interpolate_backward(
  function attention (line 317) | fn attention(

FILE: crates/burn-cubecl/src/ops/numeric.rs
  function full (line 23) | pub fn full<R: CubeRuntime, E: CubeElement>(
  function full_client (line 34) | pub fn full_client<R: CubeRuntime, E: CubeElement>(
  function full_device_dtype (line 45) | pub fn full_device_dtype<R: CubeRuntime>(
  function zeros (line 91) | pub fn zeros<R: CubeRuntime>(device: R::Device, shape: Shape, dtype: DTy...
  function ones (line 97) | pub fn ones<R: CubeRuntime>(device: R::Device, shape: Shape, dtype: DTyp...
  function zeros_client (line 103) | pub fn zeros_client<R: CubeRuntime>(
  function ones_client (line 113) | pub fn ones_client<R: CubeRuntime>(
  function empty_device (line 123) | pub fn empty_device<R: CubeRuntime, E: CubeElement>(
  function empty_device_dtype (line 140) | pub fn empty_device_dtype<R: CubeRuntime>(
  function empty_device_contiguous_dtype (line 152) | pub fn empty_device_contiguous_dtype<R: CubeRuntime>(
  function add (line 165) | pub fn add<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: CubeTensor<R>) -> Cu...
  function add_scalar (line 170) | pub fn add_scalar<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: InputScalar) ...
  function sub (line 175) | pub fn sub<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: CubeTensor<R>) -> Cu...
  function sub_scalar (line 180) | pub fn sub_scalar<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: InputScalar) ...
  function mul (line 185) | pub fn mul<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: CubeTensor<R>) -> Cu...
  function mul_scalar (line 190) | pub fn mul_scalar<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: InputScalar) ...
  function div (line 195) | pub fn div<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: CubeTensor<R>) -> Cu...
  function div_scalar (line 200) | pub fn div_scalar<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: InputScalar) ...
  function remainder (line 205) | pub fn remainder<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: CubeTensor<R>)...
  function remainder_scalar (line 210) | pub fn remainder_scalar<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: InputSc...
  function pow (line 215) | pub fn pow<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: CubeTensor<R>) -> Cu...
  function bitwise_and (line 220) | pub fn bitwise_and<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: CubeTensor<R...
  function bitwise_and_scalar (line 225) | pub fn bitwise_and_scalar<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: Input...
  function bitwise_or (line 230) | pub fn bitwise_or<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: CubeTensor<R>...
  function bitwise_or_scalar (line 235) | pub fn bitwise_or_scalar<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: InputS...
  function bitwise_xor (line 240) | pub fn bitwise_xor<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: CubeTensor<R...
  function bitwise_xor_scalar (line 245) | pub fn bitwise_xor_scalar<R: CubeRuntime>(lhs: CubeTensor<R>, rhs: Input...
  type CumulativeOpFamily (line 250) | pub(crate) trait CumulativeOpFamily: Send + Sync + 'static {
    type CumulativeOp (line 272) | type CumulativeOp<C: Numeric> = Self;
    type CumulativeOp (line 276) | type CumulativeOp<C: Numeric> = Self;
    type CumulativeOp (line 280) | type CumulativeOp<C: Numeric> = Self;
    type CumulativeOp (line 284) | type CumulativeOp<C: Numeric> = Self;
  type CumulativeOp (line 256) | pub(crate) trait CumulativeOp<C: Numeric>: 'static + Send + Sync {
    method execute (line 258) | fn execute(lhs: C, rhs: C) -> C;
    method init_value (line 261) | fn init_value(first_element: C) -> C;
  type SumOp (line 265) | struct SumOp;
    method execute (line 290) | fn execute(lhs: N, rhs: N) -> N {
    method init_value (line 294) | fn init_value(_first_element: N) -> N {
  type ProdOp (line 266) | struct ProdOp;
    method execute (line 301) | fn execute(lhs: N, rhs: N) -> N {
    method init_value (line 305) | fn init_value(_first_element: N) -> N {
  type MaxOp (line 267) | struct MaxOp;
    method execute (line 312) | fn execute(lhs: N, rhs: N) -> N {
    method init_value (line 316) | fn init_value(first_element: N) -> N {
  type MinOp (line 268) | struct MinOp;
    method execute (line 323) | fn execute(lhs: N, rhs: N) -> N {
    method init_value (line 327) | fn init_value(first_element: N) -> N {
  function cumulative_kernel (line 346) | fn cumulative_kernel<C: Numeric, O: CumulativeOpFamily>(
  function cumsum (line 392) | pub fn cumsum<R: CubeRuntime>(input: CubeTensor<R>, dim: usize) -> CubeT...
  function cumprod (line 397) | pub fn cumprod<R: CubeRuntime>(input: CubeTensor<R>, dim: usize) -> Cube...
  function cummin (line 402) | pub fn cummin<R: CubeRuntime>(input: CubeTensor<R>, dim: usize) -> CubeT...
  function cummax (line 407) | pub fn cummax<R: CubeRuntime>(input: CubeTensor<R>, dim: usize) -> CubeT...
  function cumulative_op (line 412) | fn cumulative_op<R: CubeRuntime, O: CumulativeOpFamily>(

FILE: crates/burn-cubecl/src/ops/qtensor.rs
  function new_qtensor_optimized (line 25) | fn new_qtensor_optimized<R: CubeRuntime>(
  function new_qtensor (line 35) | fn new_qtensor<R: CubeRuntime>(
  function empty_qtensor_optimized (line 46) | pub fn empty_qtensor_optimized<R: CubeRuntime>(
  function empty_qtensor (line 55) | pub fn empty_qtensor<R: CubeRuntime>(
  function new_quantized (line 64) | fn new_quantized<R: CubeRuntime>(
  function q_from_data (line 165) | fn q_from_data(data: TensorData, device: &Device<Self>) -> QuantizedTens...
  function quantize (line 197) | fn quantize(
  function dequantize (line 205) | fn dequantize(tensor: QuantizedTensor<Self>) -> FloatTensor<Self> {
  function q_device (line 209) | fn q_device(tensor: &QuantizedTensor<Self>) -> Device<Self> {
  function q_to_device (line 213) | fn q_to_device(tensor: QuantizedTensor<Self>, device: &Device<Self>) -> ...
  function q_reshape (line 217) | fn q_reshape(tensor: QuantizedTensor<Self>, shape: Shape) -> QuantizedTe...
  function q_into_data (line 221) | async fn q_into_data(tensor: QuantizedTensor<Self>) -> Result<TensorData...
  function q_swap_dims (line 241) | fn q_swap_dims(
  function q_permute (line 249) | fn q_permute(tensor: QuantizedTensor<Self>, axes: &[usize]) -> Quantized...
  function q_flip (line 253) | fn q_flip(_tensor: QuantizedTensor<Self>, _axes: &[usize]) -> QuantizedT...
  function q_gather (line 257) | fn q_gather(
  function q_select (line 265) | fn q_select(
  function q_slice (line 273) | fn q_slice(_tensor: QuantizedTensor<Self>, _slices: &[Slice]) -> Quantiz...
  function q_expand (line 277) | fn q_expand(_tensor: QuantizedTensor<Self>, _shape: Shape) -> QuantizedT...
  function q_matmul (line 281) | fn q_matmul(lhs: TensorPrimitive<Self>, rhs: TensorPrimitive<Self>) -> T...

FILE: crates/burn-cubecl/src/ops/tensor.rs
  function float_from_data (line 35) | fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTens...
  function float_random (line 42) | fn float_random(
  function float_into_data (line 65) | async fn float_into_data(tensor: FloatTensor<Self>) -> Result<TensorData...
  function float_device (line 69) | fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {
  function float_to_device (line 78) | fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> ...
  function float_empty (line 82) | fn float_empty(shape: Shape, device: &Device<Self>, dtype: FloatDType) -...
  function float_add (line 87) | fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_add_scalar (line 91) | fn float_add_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_zeros (line 96) | fn float_zeros(shape: Shape, device: &Device<Self>, dtype: FloatDType) -...
  function float_full (line 101) | fn float_full(
  function float_ones (line 118) | fn float_ones(shape: Shape, device: &Device<Self>, dtype: FloatDType) ->...
  function float_sub (line 123) | fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_sub_scalar (line 127) | fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_mul (line 132) | fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_mul_scalar (line 136) | fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_div (line 141) | fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_div_scalar (line 145) | fn float_div_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_remainder (line 150) | fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Fl...
  function float_remainder_scalar (line 154) | fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatT...
  function float_matmul (line 159) | fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Float...
  function float_cross (line 164) | fn float_cross(
  function float_swap_dims (line 172) | fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) ...
  function float_reshape (line 176) | fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor...
  function float_gather (line 180) | fn float_gather(
  function float_scatter_add (line 188) | fn float_scatter_add(
  function float_select (line 197) | fn float_select(
  function float_select_add (line 205) | fn float_select_add(
  function float_slice (line 214) | fn float_slice(tensor: FloatTensor<Self>, slices: &[Slice]) -> FloatTens...
  function float_slice_assign (line 233) | fn float_slice_assign(
  function float_mask_where (line 241) | fn float_mask_where(
  function float_mask_fill (line 249) | fn float_mask_fill(
  function float_equal (line 263) | fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTe...
  function float_equal_elem (line 267) | fn float_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor<S...
  function float_greater (line 272) | fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Bool...
  function float_greater_elem (line 276) | fn float_greater_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor...
  function float_greater_equal (line 281) | fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -...
  function float_greater_equal_elem (line 285) | fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> Bool...
  function float_lower (line 290) | fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTe...
  function float_lower_elem (line 294) | fn float_lower_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor<S...
  function float_lower_equal (line 299) | fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> ...
  function float_lower_equal_elem (line 303) | fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTe...
  function float_sum (line 308) | fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_max (line 312) | fn float_max(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_max_dim (line 316) | fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_min (line 327) | fn float_min(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_min_dim (line 331) | fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_max_abs (line 342) | fn float_max_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_max_abs_dim (line 352) | fn float_max_abs_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTens...
  function float_sum_dim (line 363) | fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_mean_dim (line 374) | fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<...
  function float_cumsum (line 385) | fn float_cumsum(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_cumprod (line 389) | fn float_cumprod(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_cummin (line 393) | fn float_cummin(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_cummax (line 397) | fn float_cummax(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_prod (line 401) | fn float_prod(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_prod_dim (line 411) | fn float_prod_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<...
  function float_exp (line 422) | fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_log (line 426) | fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_log1p (line 430) | fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_powf_scalar_impl (line 434) | fn float_powf_scalar_impl(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatT...
  function float_sqrt (line 455) | fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_abs (line 459) | fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sign (line 463) | fn float_sign(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cos (line 467) | fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sin (line 471) | fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_tan (line 475) | fn float_tan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cosh (line 479) | fn float_cosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sinh (line 483) | fn float_sinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_tanh (line 487) | fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_acos (line 491) | fn float_acos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_acosh (line 495) | fn float_acosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asin (line 499) | fn float_asin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asinh (line 503) | fn float_asinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan (line 507) | fn float_atan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atanh (line 511) | fn float_atanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan2 (line 515) | fn float_atan2(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatT...
  function float_round (line 519) | fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_floor (line 523) | fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_ceil (line 527) | fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_trunc (line 531) | fn float_trunc(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_erf (line 535) | fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_argmax (line 539) | fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {
  function float_argmin (line 550) | fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {
  function float_into_int (line 561) | fn float_into_int(tensor: FloatTensor<Self>) -> IntTensor<Self> {
  function float_clamp (line 565) | fn float_clamp(tensor: FloatTensor<Self>, min: Scalar, max: Scalar) -> F...
  function float_recip (line 574) | fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_repeat_dim (line 578) | fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize)...
  function float_powf (line 582) | fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTe...
  function float_permute (line 586) | fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTens...
  function float_expand (line 590) | fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<...
  function float_flip (line 594) | fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<...
  function float_cast (line 598) | fn float_cast(tensor: FloatTensor<Self>, dtype: FloatDType) -> FloatTens...
  function float_unfold (line 602) | fn float_unfold(
  function float_is_nan (line 611) | fn float_is_nan(tensor: FloatTensor<Self>) -> BoolTensor<Self> {
  function float_is_inf (line 615) | fn float_is_inf(tensor: FloatTensor<Self>) -> BoolTensor<Self> {
  function float_grid_sample_2d (line 619) | fn float_grid_sample_2d(

FILE: crates/burn-cubecl/src/ops/transaction.rs
  function tr_execute (line 18) | async fn tr_execute(

FILE: crates/burn-cubecl/src/template/base.rs
  type KernelSource (line 6) | pub trait KernelSource: Send + 'static + Sync {
    method source (line 8) | fn source(&self) -> SourceTemplate;
    method id (line 10) | fn id(&self) -> KernelId;
  type SourceKernel (line 15) | pub struct SourceKernel<K> {
  function compile (line 21) | fn compile(
  method id (line 43) | fn id(&self) -> KernelId {
  method address_type (line 47) | fn address_type(&self) -> StorageType {
  function build_info (line 84) | pub fn build_info<R: CubeRuntime, E: CubeElement>(tensors: &[&CubeTensor...

FILE: crates/burn-cubecl/src/template/source.rs
  type SourceTemplate (line 8) | pub struct SourceTemplate {
    method new (line 15) | pub fn new<S>(template: S) -> Self
    method register (line 34) | pub fn register<Name, Value>(mut self, name: Name, value: Value) -> Self
    method add_template (line 44) | pub fn add_template<S>(mut self, template: S) -> Self
    method complete (line 53) | pub fn complete(mut self) -> String {

FILE: crates/burn-cubecl/src/tensor/base.rs
  type CubeTensor (line 19) | pub struct CubeTensor<R: CubeRuntime> {
  function from (line 35) | fn from(val: CubeTensor<R>) -> Self {
  function check_equivalence (line 47) | fn check_equivalence(&self, other: Self) {
  function fmt (line 72) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method clone (line 88) | fn clone(&self) -> Self {
  method dtype (line 101) | fn dtype(&self) -> DType {
  method shape (line 105) | fn shape(&self) -> Shape {
  method rank (line 109) | fn rank(&self) -> usize {
  method scheme (line 115) | fn scheme(&self) -> &QuantScheme {
  function new (line 132) | pub fn new(
  function new_contiguous (line 150) | pub fn new_contiguous(
  function to_client (line 177) | pub fn to_client(&self, client: ComputeClient<R>, device: R::Device) -> ...
  function binding (line 196) | pub fn binding(self) -> TensorBinding<R> {
  function elem_size (line 206) | pub fn elem_size(&self) -> usize {
  function into_tensor_arg (line 211) | pub fn into_tensor_arg(self) -> TensorArg<R> {
  function into_array_arg (line 216) | pub fn into_array_arg(self) -> ArrayArg<R> {
  function as_tensor_alias (line 221) | pub fn as_tensor_alias(&self, input_pos: usize) -> TensorArg<R> {
  function into_linear_view (line 230) | pub fn into_linear_view(self) -> LinearViewLaunch<R> {
  function as_linear_view_alias (line 237) | pub fn as_linear_view_alias(&self, input_pos: usize) -> LinearViewLaunch...
  function into_linear_view_like (line 244) | pub fn into_linear_view_like(self, reference: &Self) -> LinearViewLaunch...
  function required_address_type (line 251) | pub fn required_address_type(&self) -> AddressType {
  function try_scheme (line 262) | pub fn try_scheme(&self) -> Option<&QuantScheme> {
  function can_mut_broadcast (line 269) | pub(crate) fn can_mut_broadcast(&self, rhs: &Self) -> bool {
  function copy (line 289) | pub fn copy(&self) -> Self {
  function can_mut (line 311) | pub fn can_mut(&self) -> bool {
  function assert_is_on_same_device (line 316) | pub fn assert_is_on_same_device(&self, other: &Self) {
  function is_contiguous (line 331) | pub fn is_contiguous(&self) -> bool {
  function is_contiguous_buffer (line 337) | pub fn is_contiguous_buffer(&self) -> bool {
  function is_nonoverlapping (line 342) | pub fn is_nonoverlapping(&self) -> bool {
  function is_contiguous_non_increasing (line 372) | fn is_contiguous_non_increasing() {
  function is_contiguous_basic (line 377) | fn is_contiguous_basic() {
  function is_contiguous_permuted (line 382) | fn is_contiguous_permuted() {
  function is_contiguous_slice (line 387) | fn is_contiguous_slice() {
  function is_contiguous_4d_positive (line 392) | fn is_contiguous_4d_positive() {
  function is_contiguous_4d_negative (line 397) | fn is_contiguous_4d_negative() {
  function is_contiguous_4d_unit_shape (line 403) | fn is_contiguous_4d_unit_shape() {

FILE: crates/burn-cubecl/src/tensor/quantization.rs
  type QParams (line 12) | pub type QParams = burn_backend::quantization::QParams<QParamTensor>;
  function new_quantized (line 16) | pub fn new_quantized(
  function quantized_handles (line 39) | pub fn quantized_handles(&self) -> Option<(CubeTensor<R>, CubeTensor<R>)> {
  function scales (line 108) | pub fn scales(&self) -> Option<CubeTensor<R>> {

FILE: crates/burn-cubecl/src/tune_key.rs
  type CubeAutotuneKey (line 11) | pub enum CubeAutotuneKey {
  method fmt (line 21) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: crates/burn-cuda/src/lib.rs
  type Cuda (line 10) | pub type Cuda<F = f32, I = i32> = CubeBackend<CudaRuntime, F, I, u8>;
  type Cuda (line 13) | pub type Cuda<F = f32, I = i32> = burn_fusion::Fusion<CubeBackend<CudaRu...
  function should_support_dtypes (line 22) | fn should_support_dtypes() {

FILE: crates/burn-dataset/examples/hf_dataset.rs
  type MnistItemRaw (line 6) | struct MnistItemRaw {
  function main (line 10) | fn main() {

FILE: crates/burn-dataset/examples/speech_commands.rs
  function speech_command (line 5) | fn speech_command() {
  function main (line 20) | fn main() {

FILE: crates/burn-dataset/src/audio/speech_commands.rs
  type MappedDataset (line 10) | type MappedDataset = MapperDataset<SqliteDataset<SpeechItemRaw>, Convert...
  type SpeechCommandClass (line 18) | pub enum SpeechCommandClass {
  type SpeechItemRaw (line 69) | pub struct SpeechItemRaw {
  type SpeechItem (line 89) | pub struct SpeechItem {
  type SpeechCommandsDataset (line 115) | pub struct SpeechCommandsDataset {
    method new (line 121) | pub fn new(split: &str) -> Self {
    method train (line 132) | pub fn train() -> Self {
    method test (line 137) | pub fn test() -> Self {
    method validation (line 142) | pub fn validation() -> Self {
    method num_classes (line 147) | pub fn num_classes() -> usize {
    method get (line 153) | fn get(&self, index: usize) -> Option<SpeechItem> {
    method len (line 157) | fn len(&self) -> usize {
  type ConvertSamples (line 163) | struct ConvertSamples;
    method to_speechcommandclass (line 167) | fn to_speechcommandclass(label: usize) -> SpeechCommandClass {
    method to_audiosamples (line 172) | fn to_audiosamples(bytes: &Vec<u8>) -> (Vec<f32>, usize) {
    method map (line 196) | fn map(&self, item: &SpeechItemRaw) -> SpeechItem {

FILE: crates/burn-dataset/src/dataset/base.rs
  type Dataset (line 6) | pub trait Dataset<I>: Send + Sync {
    method get (line 8) | fn get(&self, index: usize) -> Option<I>;
    method len (line 11) | fn len(&self) -> usize;
    method is_empty (line 14) | fn is_empty(&self) -> bool {
    method iter (line 19) | fn iter(&self) -> DatasetIterator<'_, I>
  function get (line 31) | fn get(&self, index: usize) -> Option<I> {
  function len (line 35) | fn len(&self) -> usize {
  function get (line 41) | fn get(&self, index: usize) -> Option<I> {
  function len (line 45) | fn len(&self) -> usize {
  function get (line 54) | fn get(&self, index: usize) -> Option<I> {
  function len (line 58) | fn len(&self) -> usize {
  function get (line 64) | fn get(&self, index: usize) -> Option<I> {
  function len (line 68) | fn len(&self) -> usize {

FILE: crates/burn-dataset/src/dataset/dataframe.rs
  type DataframeDatasetError (line 16) | pub enum DataframeDatasetError {
    method custom (line 23) | fn custom<T: std::fmt::Display>(msg: T) -> Self {
  type DataframeDataset (line 32) | pub struct DataframeDataset<I> {
  function new (line 52) | pub fn new(df: DataFrame) -> Result<Self, DataframeDatasetError> {
  function get (line 88) | fn get(&self, index: usize) -> Option<I> {
  function len (line 96) | fn len(&self) -> usize {
  function is_empty (line 101) | fn is_empty(&self) -> bool {
  type RowDeserializer (line 107) | struct RowDeserializer<'a> {
  function new (line 120) | fn new(row: &'a Row, column_name_mapping: &'a Vec<usize>) -> RowDeserial...
  type Error (line 130) | type Error = DataframeDatasetError;
  function deserialize_any (line 132) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, DataframeDat...
  function deserialize_struct (line 164) | fn deserialize_struct<V>(
  type Error (line 184) | type Error = DataframeDatasetError;
  function next_element_seed (line 186) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  type FieldExtractor (line 203) | struct FieldExtractor {
  type Error (line 208) | type Error = de::value::Error;
  function deserialize_any (line 210) | fn deserialize_any<V>(self, _visitor: V) -> core::result::Result<V::Valu...
  function deserialize_struct (line 217) | fn deserialize_struct<V>(
  function extract_field_names (line 242) | fn extract_field_names<'de, T>() -> Vec<&'static str>
  type TestData (line 258) | struct TestData {
  function create_test_dataframe (line 272) | fn create_test_dataframe() -> DataFrame {
  function test_dataframe_dataset_creation (line 291) | fn test_dataframe_dataset_creation() {
  function test_dataframe_dataset_length (line 298) | fn test_dataframe_dataset_length() {
  function test_dataframe_dataset_get (line 306) | fn test_dataframe_dataset_get() {
  function test_dataframe_dataset_out_of_bounds (line 359) | fn test_dataframe_dataset_out_of_bounds() {
  function test_dataframe_dataset (line 366) | fn test_dataframe_dataset() {
  function test_non_existing_struct_fields (line 413) | fn test_non_existing_struct_fields() {
  function test_partial_table (line 431) | fn test_partial_table() {

FILE: crates/burn-dataset/src/dataset/fake.rs
  type FakeDataset (line 5) | pub struct FakeDataset<I> {
  function new (line 11) | pub fn new(size: usize) -> Self {
  function iter (line 23) | fn iter(&self) -> DatasetIterator<'_, I> {
  function get (line 27) | fn get(&self, index: usize) -> Option<I> {
  function len (line 31) | fn len(&self) -> usize {
  function is_empty (line 35) | fn is_empty(&self) -> bool {

FILE: crates/burn-dataset/src/dataset/in_memory.rs
  type InMemDataset (line 12) | pub struct InMemDataset<I> {
  function new (line 18) | pub fn new(items: Vec<I>) -> Self {
  function get (line 27) | fn get(&self, index: usize) -> Option<I> {
  function len (line 30) | fn len(&self) -> usize {
  function from_dataset (line 40) | pub fn from_dataset(dataset: &impl Dataset<I>) -> Self {
  function from_json_rows (line 48) | pub fn from_json_rows<P: AsRef<Path>>(path: P) -> Result<Self, std::io::...
  function from_csv (line 72) | pub fn from_csv<P: AsRef<Path>>(
  constant DB_FILE (line 100) | const DB_FILE: &str = "tests/data/sqlite-dataset.db";
  constant JSON_FILE (line 101) | const JSON_FILE: &str = "tests/data/dataset.json";
  constant CSV_FILE (line 102) | const CSV_FILE: &str = "tests/data/dataset.csv";
  constant CSV_FMT_FILE (line 103) | const CSV_FMT_FILE: &str = "tests/data/dataset-fmt.csv";
  type SqlDs (line 105) | type SqlDs = SqliteDataset<Sample>;
  type Sample (line 108) | pub struct Sample {
  type SampleCsv (line 117) | pub struct SampleCsv {
  function train_dataset (line 125) | fn train_dataset() -> SqlDs {
  function from_dataset (line 130) | pub fn from_dataset(train_dataset: SqlDs) {
  function from_json_rows (line 141) | pub fn from_json_rows() {
  function from_csv_rows (line 153) | pub fn from_csv_rows() {
  function from_csv_rows_fmt (line 168) | pub fn from_csv_rows_fmt() {
  function given_in_memory_dataset_when_iterate_should_iterate_though_all_items (line 184) | pub fn given_in_memory_dataset_when_iterate_should_iterate_though_all_it...

FILE: crates/burn-dataset/src/dataset/iterator.rs
  type DatasetIterator (line 5) | pub struct DatasetIterator<'a, I> {
  function new (line 12) | pub fn new<D>(dataset: &'a D) -> Self
  type Item (line 24) | type Item = I;
  method next (line 26) | fn next(&mut self) -> Option<I> {

FILE: crates/burn-dataset/src/dataset/sqlite.rs
  type Result (line 25) | pub type Result<T> = core::result::Result<T, SqliteDatasetError>;
  type SqliteDatasetError (line 29) | pub enum SqliteDatasetError {
    method from (line 60) | fn from(s: &'static str) -> Self {
  type SqliteDataset (line 91) | pub struct SqliteDataset<I> {
  function from_db_file (line 104) | pub fn from_db_file<P: AsRef<Path>>(db_file: P, split: &str) -> Result<S...
  function check_if_row_serialized (line 136) | fn check_if_row_serialized(
  function db_file (line 185) | pub fn db_file(&self) -> PathBuf {
  function split (line 190) | pub fn split(&self) -> &str {
  function get (line 200) | fn get(&self, index: usize) -> Option<I> {
  function len (line 233) | fn len(&self) -> usize {
  function fetch_columns_and_len (line 239) | fn fetch_columns_and_len(
  function create_conn_pool (line 267) | fn create_conn_pool<P: AsRef<Path>>(
  type SqliteDatasetStorage (line 284) | pub struct SqliteDatasetStorage {
    method from_name (line 296) | pub fn from_name(name: &str) -> Self {
    method from_file (line 309) | pub fn from_file<P: AsRef<Path>>(db_file: P) -> Self {
    method with_base_dir (line 322) | pub fn with_base_dir<P: AsRef<Path>>(mut self, base_dir: P) -> Self {
    method exists (line 332) | pub fn exists(&self) -> bool {
    method db_file (line 341) | pub fn db_file(&self) -> PathBuf {
    method base_dir (line 360) | pub fn base_dir(base_dir: Option<PathBuf>) -> PathBuf {
    method writer (line 378) | pub fn writer<I>(&self, overwrite: bool) -> Result<SqliteDatasetWriter...
    method reader (line 394) | pub fn reader<I>(&self, split: &str) -> Result<SqliteDataset<I>>
  type SqliteDatasetWriter (line 417) | pub struct SqliteDatasetWriter<I> {
  function new (line 441) | pub fn new<P: AsRef<Path>>(db_file: P, overwrite: bool) -> Result<Self> {
  function init (line 460) | fn init(mut self) -> Result<Self> {
  function write (line 515) | pub fn write(&self, split: &str, item: &I) -> Result<usize> {
  function set_completed (line 555) | pub fn set_completed(&mut self) -> Result<()> {
  function create_table (line 590) | fn create_table(&self, split: &str) -> Result<()> {
  function pragma_update_with_error_handling (line 617) | fn pragma_update_with_error_handling(
  type SqlDs (line 641) | type SqlDs = SqliteDataset<Sample>;
  type Sample (line 644) | pub struct Sample {
  function train_dataset (line 653) | fn train_dataset() -> SqlDs {
  function len (line 658) | pub fn len(train_dataset: SqlDs) {
  function get_some (line 663) | pub fn get_some(train_dataset: SqlDs) {
  function get_none (line 673) | pub fn get_none(train_dataset: SqlDs) {
  function multi_thread (line 678) | pub fn multi_thread(train_dataset: SqlDs) {
  function sqlite_dataset_storage (line 694) | fn sqlite_dataset_storage() {
  type Complex (line 720) | pub struct Complex {
  function tmp_dir (line 731) | fn tmp_dir() -> TempDir {
  type Writer (line 736) | type Writer = SqliteDatasetWriter<Complex>;
  function writer_fixture (line 741) | fn writer_fixture(tmp_dir: TempDir) -> (Writer, TempDir) {
  function test_new (line 752) | fn test_new() {
  function sqlite_writer_write (line 773) | pub fn sqlite_writer_write(writer_fixture: (Writer, TempDir)) {
  function sqlite_writer_write_multi_thread (line 812) | pub fn sqlite_writer_write_multi_thread(writer_fixture: (Writer, TempDir...

FILE: crates/burn-dataset/src/lib.rs
  function string_items (line 44) | pub fn string_items() -> Vec<String> {

FILE: crates/burn-dataset/src/nlp/ag_news.rs
  constant AG_NEWS_URL (line 35) | const AG_NEWS_URL: &str = "https://s3.amazonaws.com/fast-ai-nlp/ag_news_...
  type AgNewsItem (line 41) | pub struct AgNewsItem {
  type AgNewsDataset (line 56) | pub struct AgNewsDataset {
    method new (line 69) | pub fn new() -> Self {
    method download (line 79) | fn download() -> PathBuf {
    method parse_csv (line 118) | fn parse_csv(file_path: &str) -> InMemDataset<AgNewsItem> {
    method train (line 129) | pub fn train(&self) -> InMemDataset<AgNewsItem> {
    method test (line 138) | pub fn test(&self) -> InMemDataset<AgNewsItem> {
  constant TRAIN_DATASET_LEN (line 150) | const TRAIN_DATASET_LEN: usize = 120000;
  constant TEST_DATASET_LEN (line 151) | const TEST_DATASET_LEN: usize = 7600;
  function test_agnews_download (line 154) | fn test_agnews_download() {
  function test_agnews_len (line 160) | fn test_agnews_len() {
  function test_agnews_first_and_last_item (line 169) | fn test_agnews_first_and_last_item() {
  function compare_item (line 208) | fn compare_item(item: &AgNewsItem, target: &(String, String, String)) ->...

FILE: crates/burn-dataset/src/nlp/text_folder.rs
  constant SUPPORTED_FILES (line 12) | const SUPPORTED_FILES: [&str; 1] = ["txt"];
  type TextData (line 16) | pub struct TextData {
  type TextDatasetItem (line 26) | pub struct TextDatasetItem {
  type TextDatasetItemRaw (line 36) | struct TextDatasetItemRaw {
    method new (line 45) | fn new<P: AsRef<Path>>(text_path: P, label: String) -> TextDatasetItem...
  type PathToTextDatasetItem (line 53) | struct PathToTextDatasetItem {
    method map (line 113) | fn map(&self, item: &TextDatasetItemRaw) -> TextDatasetItem {
  function parse_text_content (line 58) | fn parse_text_content(text_path: &PathBuf) -> String {
  type TextLoaderError (line 133) | pub enum TextLoaderError {
  type TextDatasetMapper (line 151) | type TextDatasetMapper =
  type TextFolderDataset (line 155) | pub struct TextFolderDataset {
    method get (line 160) | fn get(&self, index: usize) -> Option<TextDatasetItem> {
    method len (line 164) | fn len(&self) -> usize {
    method new_classification (line 178) | pub fn new_classification<P: AsRef<Path>>(root: P) -> Result<Self, Tex...
    method new_classification_with (line 193) | pub fn new_classification_with<P, S>(root: P, extensions: &[S]) -> Res...
    method new_classification_with_items (line 258) | pub fn new_classification_with_items<P: AsRef<Path>, S: AsRef<str>>(
    method with_items (line 288) | fn with_items<S: AsRef<str>>(
    method check_extension (line 313) | fn check_extension<S: AsRef<str>>(extension: &S) -> Result<String, Tex...
  constant TEXT_ROOT (line 330) | const TEXT_ROOT: &str = "tests/data/text_folder";
  function test_text_folder_dataset (line 333) | fn test_text_folder_dataset() {
  function test_text_folder_dataset_with_invalid_extension (line 365) | fn test_text_folder_dataset_with_invalid_extension() {
  function test_text_folder_dataset_with_items (line 372) | fn test_text_folder_dataset_with_items() {
  function compare_item (line 418) | fn compare_item(item: &TextDatasetItem, target: &(String, usize)) -> bool {

FILE: crates/burn-dataset/src/source/huggingface/downloader.rs
  constant PYTHON_SOURCE (line 11) | const PYTHON_SOURCE: &str = include_str!("importer.py");
  constant VENV_BIN_PYTHON (line 13) | const VENV_BIN_PYTHON: &str = "bin/python3";
  constant VENV_BIN_PYTHON (line 15) | const VENV_BIN_PYTHON: &str = "Scripts\\python";
  type ImporterError (line 19) | pub enum ImporterError {
  type HuggingfaceDatasetLoader (line 65) | pub struct HuggingfaceDatasetLoader {
    method new (line 78) | pub fn new(name: &str) -> Self {
    method with_subset (line 96) | pub fn with_subset(mut self, subset: &str) -> Self {
    method with_base_dir (line 104) | pub fn with_base_dir(mut self, base_dir: &str) -> Self {
    method with_huggingface_token (line 112) | pub fn with_huggingface_token(mut self, huggingface_token: &str) -> Se...
    method with_huggingface_cache_dir (line 120) | pub fn with_huggingface_cache_dir(mut self, huggingface_cache_dir: &st...
    method with_huggingface_data_dir (line 130) | pub fn with_huggingface_data_dir(mut self, huggingface_data_dir: &str)...
    method with_trust_remote_code (line 138) | pub fn with_trust_remote_code(mut self, trust_remote_code: bool) -> Se...
    method with_use_python_venv (line 148) | pub fn with_use_python_venv(mut self, use_python_venv: bool) -> Self {
    method dataset (line 154) | pub fn dataset<I: DeserializeOwned + Clone>(
    method db_file (line 166) | pub fn db_file(self) -> Result<PathBuf, ImporterError> {
  function import (line 207) | fn import(
  function check_python_version_is_3 (line 270) | fn check_python_version_is_3(python: &str) -> bool {
  function get_python_name (line 291) | fn get_python_name() -> Result<&'static str, ImporterError> {
  function importer_script_path (line 301) | fn importer_script_path(base_dir: &Path) -> PathBuf {
  function install_python_deps (line 308) | fn install_python_deps(base_dir: &Path) -> Result<PathBuf, ImporterError> {

FILE: crates/burn-dataset/src/source/huggingface/importer.py
  function download_and_export (line 9) | def download_and_export(
  function disable_decoding (line 86) | def disable_decoding(dataset):
  function rename_columns (line 99) | def rename_columns(dataset):
  function blob_columns (line 113) | def blob_columns(dataset):
  function set_sqlite_pragma (line 125) | def set_sqlite_pragma(dbapi_connection, connection_record):
  function add_pk_column (line 135) | def add_pk_column(target, connection, **kw):
  function print_table_info (line 142) | def print_table_info(engine):
  function parse_args (line 155) | def parse_args():
  function run (line 192) | def run():

FILE: crates/burn-dataset/src/transform/composed.rs
  type ComposedDataset (line 5) | pub struct ComposedDataset<D> {
  function get (line 14) | fn get(&self, index: usize) -> Option<I> {
  function len (line 24) | fn len(&self) -> usize {
  function test_composed_dataset (line 39) | fn test_composed_dataset() {

FILE: crates/burn-dataset/src/transform/mapper.rs
  type Mapper (line 5) | pub trait Mapper<I, O>: Send + Sync {
    method map (line 7) | fn map(&self, item: &I) -> O;
  type MapperDataset (line 12) | pub struct MapperDataset<D, M, I> {
  function get (line 25) | fn get(&self, index: usize) -> Option<O> {
  function len (line 30) | fn len(&self) -> usize {
  function given_mapper_dataset_when_iterate_should_iterate_though_all_map_items (line 41) | pub fn given_mapper_dataset_when_iterate_should_iterate_though_all_map_i...

FILE: crates/burn-dataset/src/transform/options.rs
  type RngSource (line 32) | pub enum RngSource {
    method from (line 55) | fn from(seed: u64) -> Self {
    method from (line 61) | fn from(rng: StdRng) -> Self {
    method from (line 72) | fn from(rng: &mut StdRng) -> Self {
  method from (line 45) | fn from(source: RngSource) -> Self {
  type SizeConfig (line 79) | pub enum SizeConfig {
    method source (line 95) | pub fn source() -> Self {
    method resolve (line 108) | pub fn resolve(self, source_size: usize) -> usize {
    method from (line 121) | fn from(size: usize) -> Self {
    method from (line 127) | fn from(ratio: f64) -> Self {
  function test_rng_source_default (line 138) | fn test_rng_source_default() {
  function test_rng_source_seed (line 148) | fn test_rng_source_seed() {
  function test_rng_source_rng (line 159) | fn test_rng_source_rng() {
  function test_size_config (line 189) | fn test_size_config() {

FILE: crates/burn-dataset/src/transform/partial.rs
  type PartialDataset (line 6) | pub struct PartialDataset<D, I> {
  function split (line 18) | pub fn split(dataset: D, num: usize) -> Vec<PartialDataset<Arc<D>, I>> {
  function split_chunks (line 44) | pub fn split_chunks(
  function get (line 90) | fn get(&self, index: usize) -> Option<I> {
  function len (line 98) | fn len(&self) -> usize {
  function test_start_from_beginning (line 110) | fn test_start_from_beginning() {
  function test_start_inside (line 136) | fn test_start_inside() {
  function test_split_contains_all_items_without_duplicates (line 162) | fn test_split_contains_all_items_without_duplicates() {
  function test_split_chunks_contains_all_items_without_duplicates (line 184) | fn test_split_chunks_contains_all_items_without_duplicates() {

FILE: crates/burn-dataset/src/transform/sampler.rs
  type SamplerDatasetOptions (line 9) | pub struct SamplerDatasetOptions {
    method from (line 34) | fn from(option: Option<T>) -> Self {
    method from (line 43) | fn from(size: usize) -> Self {
    method with_replace_samples (line 50) | pub fn with_replace_samples(self, replace_samples: bool) -> Self {
    method with_replacement (line 58) | pub fn with_replacement(self) -> Self {
    method without_replacement (line 63) | pub fn without_replacement(self) -> Self {
    method with_size (line 68) | pub fn with_size<S>(self, source: S) -> Self
    method with_source_size (line 79) | pub fn with_source_size(self) -> Self {
    method with_fixed_size (line 84) | pub fn with_fixed_size(self, size: usize) -> Self {
    method with_size_ratio (line 89) | pub fn with_size_ratio(self, size_ratio: f64) -> Self {
    method with_rng (line 94) | pub fn with_rng<R>(self, rng: R) -> Self
    method with_system_rng (line 105) | pub fn with_system_rng(self) -> Self {
    method with_seed (line 110) | pub fn with_seed(self, seed: u64) -> Self {
  method default (line 21) | fn default() -> Self {
  type SamplerDataset (line 127) | pub struct SamplerDataset<D, I> {
  type SamplerState (line 133) | enum SamplerState {
  function new (line 189) | pub fn new<O>(dataset: D, options: O) -> Self
  function with_replacement (line 213) | pub fn with_replacement(dataset: D, size: usize) -> Self {
  function without_replacement (line 236) | pub fn without_replacement(dataset: D, size: usize) -> Self {
  function is_with_replacement (line 250) | pub fn is_with_replacement(&self) -> bool {
  function index (line 257) | fn index(&self) -> usize {
  function get (line 294) | fn get(&self, index: usize) -> Option<I> {
  function len (line 302) | fn len(&self) -> usize {
  function test_samplerdataset_options (line 317) | fn test_samplerdataset_options() {
  function sampler_dataset_constructors_test (line 352) | fn sampler_dataset_constructors_test() {
  function sampler_dataset_with_replacement_iter (line 370) | fn sampler_dataset_with_replacement_iter() {
  function sampler_dataset_without_replacement_bucket_test (line 387) | fn sampler_dataset_without_replacement_bucket_test() {
  function sampler_dataset_without_replacement_uniform_order_test (line 418) | fn sampler_dataset_without_replacement_uniform_order_test() {

FILE: crates/burn-dataset/src/transform/selection.rs
  function iota (line 18) | pub fn iota(size: usize) -> Vec<usize> {
  function shuffled_indices (line 32) | pub fn shuffled_indices(size: usize, rng: &mut StdRng) -> Vec<usize> {
  type SelectionDataset (line 42) | pub struct SelectionDataset<D, I>
  function from_indices_checked (line 74) | pub fn from_indices_checked<S>(dataset: S, indices: Vec<usize>) -> Self
  function from_indices_unchecked (line 98) | pub fn from_indices_unchecked<S>(dataset: S, indices: Vec<usize>) -> Self
  function new_select_all (line 122) | pub fn new_select_all<S>(dataset: S) -> Self
  function new_shuffled (line 144) | pub fn new_shuffled<S, R>(dataset: S, rng_source: R) -> Self
  function shuffle (line 161) | pub fn shuffle<R>(&mut self, rng_source: R)
  function slice (line 181) | pub fn slice(&self, start: usize, end: usize) -> Self {
  function split (line 198) | pub fn split(&self, num: usize) -> Vec<Self> {
  function get (line 228) | fn get(&self, index: usize) -> Option<I> {
  function len (line 233) | fn len(&self) -> usize {
  function test_iota (line 245) | fn test_iota() {
  function test_shuffled_indices_same_seed_is_deterministic (line 253) | fn test_shuffled_indices_same_seed_is_deterministic() {
  function test_shuffled_indices_forked_rngs_differ (line 270) | fn test_shuffled_indices_forked_rngs_differ() {
  function test_from_indices_checked_panics (line 287) | fn test_from_indices_checked_panics() {
  function test_checked_selection_dataset (line 294) | fn test_checked_selection_dataset() {
  function test_shuffled_dataset (line 313) | fn test_shuffled_dataset() {
  function test_slice (line 332) | fn test_slice() {
  function test_split (line 354) | fn test_split() {

FILE: crates/burn-dataset/src/transform/shuffle.rs
  type ShuffledDataset (line 14) | pub struct ShuffledDataset<D, I>
  function new (line 39) | pub fn new<R>(dataset: D, rng_source: R) -> Self
  function with_seed (line 61) | pub fn with_seed(dataset: D, seed: u64) -> Self {
  function get (line 71) | fn get(&self, index: usize) -> Option<I> {
  function len (line 75) | fn len(&self) -> usize {
  function test_shuffled_dataset (line 89) | fn test_shuffled_dataset() {

FILE: crates/burn-dataset/src/transform/window.rs
  type Window (line 6) | pub trait Window<I> {
    method window (line 12) | fn window(&self, current: usize, size: NonZeroUsize) -> Option<Vec<I>>;
  method window (line 16) | fn window(&self, current: usize, size: NonZeroUsize) -> Option<Vec<I>> {
  type Windows (line 24) | pub trait Windows<I> {
    method windows (line 26) | fn windows(&self, size: usize) -> WindowsIterator<'_, I>;
  method windows (line 51) | fn windows(&self, size: usize) -> WindowsIterator<'_, I> {
  type WindowsIterator (line 58) | pub struct WindowsIterator<'a, I> {
  function new (line 73) | pub fn new(dataset: &'a dyn Dataset<I>, size: NonZeroUsize) -> Self {
  type Item (line 83) | type Item = Vec<I>;
  method next (line 85) | fn next(&mut self) -> Option<Vec<I>> {
  method clone (line 92) | fn clone(&self) -> Self {
  type WindowsDataset (line 102) | pub struct WindowsDataset<D, I> {
  function new (line 120) | pub fn new(dataset: D, size: usize) -> Self
  function get (line 147) | fn get(&self, index: usize) -> Option<Vec<I>> {
  function len (line 156) | fn len(&self) -> usize {
  function windows_should_be_equal_to_vec_windows (line 172) | pub fn windows_should_be_equal_to_vec_windows() {
  function windows_dataset_should_be_equal_to_vec_windows (line 186) | pub fn windows_dataset_should_be_equal_to_vec_windows() {
  function cloned_iterator_should_be_equal (line 202) | pub fn cloned_iterator_should_be_equal() {
  function cloned_iterator_should_be_unaffected (line 215) | pub fn cloned_iterator_should_be_unaffected() {
  function windows_should_panic (line 228) | pub fn windows_should_panic() {
  function new_window_dataset_should_panic (line 237) | pub fn new_window_dataset_should_panic() {
  function window_dataset_len_should_be_equal (line 245) | pub fn window_dataset_len_should_be_equal() {
  function window_iterator_should_be_empty (line 254) | pub fn window_iterator_should_be_empty() {
  function window_dataset_len_should_be_zero (line 264) | pub fn window_dataset_len_should_be_zero() {
  function window_dataset_get_should_be_equal (line 273) | pub fn window_dataset_get_should_be_equal() {
  function window_dataset_get_should_be_none (line 283) | pub fn window_dataset_get_should_be_none() {

FILE: crates/burn-dataset/src/vision/cifar.rs
  constant CIFAR10_URL (line 49) | const CIFAR10_URL: &str = "https://s3.amazonaws.com/fast-ai-sample/cifar...
  constant CIFAR100_URL (line 53) | const CIFAR100_URL: &str = "https://s3.amazonaws.com/fast-ai-imageclas/c...
  type CifarType (line 61) | pub enum CifarType {
  type CifarDataset (line 79) | pub struct CifarDataset {
    method new (line 88) | pub fn new(cifar_type: CifarType) -> Self {
    method train (line 98) | pub fn train(&self) -> ImageFolderDataset {
    method test (line 106) | pub fn test(&self) -> ImageFolderDataset {
  function download (line 116) | fn download(cifar_type: &CifarType) -> PathBuf {
  constant TRAINDATASET_LEN (line 163) | const TRAINDATASET_LEN: usize = 50000;
  constant TESTDATASET_LEN (line 164) | const TESTDATASET_LEN: usize = 10000;
  constant CIFAR10_LABEL_MIN (line 167) | const CIFAR10_LABEL_MIN: usize = 0;
  constant CIFAR10_LABEL_MAX (line 168) | const CIFAR10_LABEL_MAX: usize = 9;
  constant CIFAR100_LABEL_MIN (line 171) | const CIFAR100_LABEL_MIN: usize = 0;
  constant CIFAR100_LABEL_MAX (line 172) | const CIFAR100_LABEL_MAX: usize = 99;
  function test_cifar10_download (line 175) | fn test_cifar10_download() {
  function test_cifar100_download (line 181) | fn test_cifar100_download() {
  function test_cifar10_len (line 187) | fn test_cifar10_len() {
  function test_cifar100_len (line 196) | fn test_cifar100_len() {
  function test_cifar10_label_range (line 205) | fn test_cifar10_label_range() {
  function test_cifar100_label_range (line 214) | fn test_cifar100_label_range() {
  function get_label_range (line 222) | fn get_label_range(dataset: &ImageFolderDataset) -> (usize, usize) {

FILE: crates/burn-dataset/src/vision/image_folder.rs
  constant SUPPORTED_FILES (line 13) | const SUPPORTED_FILES: [&str; 4] = ["bmp", "jpg", "jpeg", "png"];
  constant BBOX_MIN_NUM_VALUES (line 14) | const BBOX_MIN_NUM_VALUES: usize = 4;
  type PixelDepth (line 18) | pub enum PixelDepth {
  type Error (line 28) | type Error = &'static str;
  function try_from (line 30) | fn try_from(value: PixelDepth) -> Result<Self, Self::Error> {
  type Error (line 40) | type Error = &'static str;
  function try_from (line 42) | fn try_from(value: PixelDepth) -> Result<Self, Self::Error> {
  type Error (line 52) | type Error = &'static str;
  function try_from (line 54) | fn try_from(value: PixelDepth) -> Result<Self, Self::Error> {
  type Annotation (line 65) | pub enum Annotation {
  type SegmentationMask (line 80) | pub struct SegmentationMask {
  type BoundingBox (line 87) | pub struct BoundingBox {
  type ImageDatasetItem (line 97) | pub struct ImageDatasetItem {
  type AnnotationRaw (line 116) | enum AnnotationRaw {
  type ImageDatasetItemRaw (line 124) | struct ImageDatasetItemRaw {
    method new (line 133) | fn new<P: AsRef<Path>>(image_path: P, annotation: AnnotationRaw) -> Im...
  type PathToImageDatasetItem (line 141) | struct PathToImageDatasetItem {
    method map (line 359) | fn map(&self, item: &ImageDatasetItemRaw) -> ImageDatasetItem {
  function segmentation_mask_to_vec_usize (line 145) | fn segmentation_mask_to_vec_usize(mask_path: &PathBuf) -> Vec<usize> {
  function parse_image_annotation (line 172) | fn parse_image_annotation(
  function parse_coco_classes (line 200) | fn parse_coco_classes(
  function parse_coco_bbox_annotations (line 236) | fn parse_coco_bbox_annotations(
  function parse_coco_images (line 310) | fn parse_coco_images<P: AsRef<Path>>(
  type ImageLoaderError (line 436) | pub enum ImageLoaderError {
  type ImageDatasetMapper (line 454) | type ImageDatasetMapper =
  type ImageFolderDataset (line 458) | pub struct ImageFolderDataset {
    method get (line 463) | fn get(&self, index: usize) -> Option<ImageDatasetItem> {
    method len (line 467) | fn len(&self) -> usize {
    method new_classification (line 481) | pub fn new_classification<P: AsRef<Path>>(root: P) -> Result<Self, Ima...
    method new_classification_with (line 496) | pub fn new_classification_with<P, S>(
    method new_classification_with_items (line 567) | pub fn new_classification_with_items<P: AsRef<Path>, S: AsRef<str>>(
    method new_multilabel_classification_with_items (line 597) | pub fn new_multilabel_classification_with_items<P: AsRef<Path>, S: AsR...
    method new_segmentation_with_items (line 627) | pub fn new_segmentation_with_items<P: AsRef<Path>, S: AsRef<str>>(
    method new_coco_detection (line 659) | pub fn new_coco_detection<A: AsRef<Path>, I: AsRef<Path>>(
    method with_items (line 688) | fn with_items<S: AsRef<str>>(
    method check_extension (line 713) | fn check_extension<S: AsRef<str>>(extension: &S) -> Result<String, Ima...
  constant DATASET_ROOT (line 728) | const DATASET_ROOT: &str = "tests/data/image_folder";
  constant SEGMASK_ROOT (line 729) | const SEGMASK_ROOT: &str = "tests/data/segmask_folder";
  constant COCO_JSON (line 730) | const COCO_JSON: &str = "tests/data/dataset_coco.json";
  constant COCO_IMAGES (line 731) | const COCO_IMAGES: &str = "tests/data/image_folder_coco";
  function image_folder_dataset (line 734) | pub fn image_folder_dataset() {
  function image_folder_dataset_filtered (line 748) | pub fn image_folder_dataset_filtered() {
  function image_folder_dataset_with_items_sizes (line 761) | pub fn image_folder_dataset_with_items_sizes() {
  function image_folder_dataset_with_items (line 801) | pub fn image_folder_dataset_with_items() {
  function image_folder_dataset_multilabel (line 822) | pub fn image_folder_dataset_multilabel() {
  function image_folder_dataset_invalid_extension (line 865) | pub fn image_folder_dataset_invalid_extension() {
  function pixel_depth_try_into_u8 (line 871) | pub fn pixel_depth_try_into_u8() {
  function pixel_depth_try_into_u8_invalid (line 879) | pub fn pixel_depth_try_into_u8_invalid() {
  function pixel_depth_try_into_u16 (line 884) | pub fn pixel_depth_try_into_u16() {
  function pixel_depth_try_into_u16_invalid (line 892) | pub fn pixel_depth_try_into_u16_invalid() {
  function pixel_depth_try_into_f32 (line 897) | pub fn pixel_depth_try_into_f32() {
  function pixel_depth_try_into_f32_invalid (line 905) | pub fn pixel_depth_try_into_f32_invalid() {
  function parse_image_annotation_label_string (line 910) | pub fn parse_image_annotation_label_string() {
  function parse_image_annotation_multilabel_string (line 920) | pub fn parse_image_annotation_multilabel_string() {
  function segmask_image_path_to_vec_usize (line 934) | pub fn segmask_image_path_to_vec_usize() {
  function segmask_folder_dataset (line 984) | pub fn segmask_folder_dataset() {
  function coco_detection_dataset (line 1064) | pub fn coco_detection_dataset() {

FILE: crates/burn-dataset/src/vision/mnist.rs
  constant URL (line 16) | const URL: &str = "https://storage.googleapis.com/cvdf-datasets/mnist/";
  constant TRAIN_IMAGES (line 17) | const TRAIN_IMAGES: &str = "train-images-idx3-ubyte";
  constant TRAIN_LABELS (line 18) | const TRAIN_LABELS: &str = "train-labels-idx1-ubyte";
  constant TEST_IMAGES (line 19) | const TEST_IMAGES: &str = "t10k-images-idx3-ubyte";
  constant TEST_LABELS (line 20) | const TEST_LABELS: &str = "t10k-labels-idx1-ubyte";
  constant WIDTH (line 22) | const WIDTH: usize = 28;
  constant HEIGHT (line 23) | const HEIGHT: usize = 28;
  type MnistItem (line 27) | pub struct MnistItem {
  type MnistItemRaw (line 36) | struct MnistItemRaw {
  type BytesToImage (line 41) | struct BytesToImage;
    method map (line 45) | fn map(&self, item: &MnistItemRaw) -> MnistItem {
  type MappedDataset (line 64) | type MappedDataset = MapperDataset<InMemDataset<MnistItemRaw>, BytesToIm...
  type MnistDataset (line 70) | pub struct MnistDataset {
    method get (line 75) | fn get(&self, index: usize) -> Option<MnistItem> {
    method len (line 79) | fn len(&self) -> usize {
    method train (line 86) | pub fn train() -> Self {
    method test (line 91) | pub fn test() -> Self {
    method new (line 95) | fn new(split: &str) -> Self {
    method download (line 120) | fn download(split: &str) -> PathBuf {
    method download_file (line 149) | fn download_file<P: AsRef<Path>>(name: &str, dest_dir: &P) -> PathBuf {
    method read_images (line 170) | fn read_images<P: AsRef<Path>>(root: &P, split: &str) -> Vec<Vec<u8>> {
    method read_labels (line 198) | fn read_labels<P: AsRef<Path>>(root: &P, split: &str) -> Vec<u8> {

FILE: crates/burn-derive/src/config/analyzer.rs
  type ConfigAnalyzerFactory (line 8) | pub struct ConfigAnalyzerFactory {}
    method new (line 24) | pub fn new() -> Self {
    method create_analyzer (line 28) | pub fn create_analyzer(&self, item: &syn::DeriveInput) -> Box<dyn Conf...
    method create_struct_analyzer (line 38) | fn create_struct_analyzer(&self, name: Ident, fields: Vec<Field>) -> C...
    method create_enum_analyzer (line 69) | fn create_enum_analyzer(&self, name: Ident, data: syn::DataEnum) -> Co...
  type ConfigAnalyzer (line 10) | pub trait ConfigAnalyzer {
    method gen_new_fn (line 11) | fn gen_new_fn(&self) -> TokenStream {
    method gen_builder_fns (line 14) | fn gen_builder_fns(&self) -> TokenStream {
    method gen_serde_impl (line 17) | fn gen_serde_impl(&self) -> TokenStream;
    method gen_clone_impl (line 18) | fn gen_clone_impl(&self) -> TokenStream;
    method gen_display_impl (line 19) | fn gen_display_impl(&self) -> TokenStream;
    method gen_config_impl (line 20) | fn gen_config_impl(&self) -> TokenStream;
  type ConfigType (line 74) | enum ConfigType {
  function parse_asm (line 79) | fn parse_asm(ast: &syn::DeriveInput) -> ConfigType {

FILE: crates/burn-derive/src/config/analyzer_enum.rs
  type ConfigEnumAnalyzer (line 7) | pub struct ConfigEnumAnalyzer {
    method new (line 13) | pub fn new(name: Ident, data: syn::DataEnum) -> Self {
    method serde_enum_ident (line 17) | fn serde_enum_ident(&self) -> Ident {
    method gen_serde_enum (line 21) | fn gen_serde_enum(&self) -> TokenStream {
    method gen_serialize_fn (line 35) | fn gen_serialize_fn(&self) -> TokenStream {
    method gen_deserialize_fn (line 61) | fn gen_deserialize_fn(&self) -> TokenStream {
  method gen_serde_impl (line 88) | fn gen_serde_impl(&self) -> TokenStream {
  method gen_clone_impl (line 100) | fn gen_clone_impl(&self) -> TokenStream {
  method gen_display_impl (line 121) | fn gen_display_impl(&self) -> TokenStream {
  method gen_config_impl (line 133) | fn gen_config_impl(&self) -> TokenStream {

FILE: crates/burn-derive/src/config/analyzer_struct.rs
  type ConfigStructAnalyzer (line 6) | pub struct ConfigStructAnalyzer {
    method new (line 14) | pub fn new(
    method wrap_impl_block (line 28) | fn wrap_impl_block(&self, tokens: TokenStream) -> TokenStream {
    method names (line 38) | fn names(&self) -> Vec<FieldTypeAnalyzer> {
    method name_types (line 56) | fn name_types(&self, names: &[FieldTypeAnalyzer]) -> Vec<TokenStream> {
    method serde_struct_ident (line 71) | fn serde_struct_ident(&self) -> Ident {
    method gen_serialize_fn (line 75) | fn gen_serialize_fn(
    method gen_deserialize_fn (line 107) | fn gen_deserialize_fn(
    method gen_serde_struct (line 138) | fn gen_serde_struct(&self, names: &[TokenStream]) -> TokenStream {
  method gen_new_fn (line 151) | fn gen_new_fn(&self) -> TokenStream {
  method gen_builder_fns (line 268) | fn gen_builder_fns(&self) -> TokenStream {
  method gen_serde_impl (line 325) | fn gen_serde_impl(&self) -> TokenStream {
  method gen_clone_impl (line 341) | fn gen_clone_impl(&self) -> TokenStream {
  method gen_display_impl (line 360) | fn gen_display_impl(&self) -> TokenStream {
  method gen_config_impl (line 372) | fn gen_config_impl(&self) -> TokenStream {

FILE: crates/burn-derive/src/config/base.rs
  function derive_impl (line 4) | pub(crate) fn derive_impl(item: &syn::DeriveInput) -> proc_macro::TokenS...

FILE: crates/burn-derive/src/lib.rs
  function module_derive (line 64) | pub fn module_derive(input: TokenStream) -> TokenStream {
  function record_derive (line 71) | pub fn record_derive(input: TokenStream) -> TokenStream {
  function config_derive (line 78) | pub fn config_derive(input: TokenStream) -> TokenStream {

FILE: crates/burn-derive/src/module/base.rs
  function derive_impl (line 8) | pub(crate) fn derive_impl(ast: &syn::DeriveInput) -> TokenStream {

FILE: crates/burn-derive/src/module/codegen.rs
  type ModuleCodegen (line 11) | pub(crate) trait ModuleCodegen {
    method gen_num_params (line 14) | fn gen_num_params(&self) -> TokenStream;
    method gen_visit (line 15) | fn gen_visit(&self) -> TokenStream;
    method gen_collect_devices (line 16) | fn gen_collect_devices(&self) -> TokenStream;
    method gen_to_device (line 17) | fn gen_to_device(&self) -> TokenStream;
    method gen_fork (line 18) | fn gen_fork(&self) -> TokenStream;
    method gen_map (line 19) | fn gen_map(&self) -> TokenStream;
    method gen_valid (line 20) | fn gen_valid(&self) -> TokenStream;
    method gen_from_inner (line 21) | fn gen_from_inner(&self) -> TokenStream;
    method gen_into_record (line 22) | fn gen_into_record(&self) -> TokenStream;
    method gen_load_record (line 23) | fn gen_load_record(&self) -> TokenStream;
    method gen_clone (line 24) | fn gen_clone(&self) -> TokenStream;
    method record_codegen (line 26) | fn record_codegen(self) -> Self::RecordCodegen;
    method gen_display (line 28) | fn gen_display(&self) -> TokenStream;
    method module_generics (line 30) | fn module_generics(&self) -> &ModuleGenerics;
  function generate_module_standard (line 33) | pub(crate) fn generate_module_standard<Codegen: ModuleCodegen>(
  function generate_module_const (line 137) | pub(crate) fn generate_module_const(ast: &syn::DeriveInput) -> TokenStre...
  type GenericsParser (line 191) | struct GenericsParser {
    method from_ast (line 201) | fn from_ast(generics: &Generics, module_generics: &ModuleGenerics) -> ...
  function has_custom_display (line 354) | fn has_custom_display(attrs: &[Attribute]) -> bool {

FILE: crates/burn-derive/src/module/codegen_enum.rs
  type EnumModuleCodegen (line 10) | pub(crate) struct EnumModuleCodegen {
    method from_ast (line 233) | pub fn from_ast(ast: &syn::DeriveInput) -> syn::Result<Self> {
    method gen_variants_match_fn (line 243) | fn gen_variants_match_fn<F>(&self, func: F) -> TokenStream
    method gen_variants_match_fn_param (line 252) | fn gen_variants_match_fn_param<F>(&self, arg: &str, prefix: &str, func...
  type RecordCodegen (line 18) | type RecordCodegen = EnumModuleRecordCodegen;
  method gen_num_params (line 20) | fn gen_num_params(&self) -> TokenStream {
  method gen_visit (line 34) | fn gen_visit(&self) -> TokenStream {
  method gen_collect_devices (line 55) | fn gen_collect_devices(&self) -> TokenStream {
  method gen_to_device (line 72) | fn gen_to_device(&self) -> TokenStream {
  method gen_fork (line 86) | fn gen_fork(&self) -> TokenStream {
  method gen_map (line 100) | fn gen_map(&self) -> TokenStream {
  method gen_valid (line 122) | fn gen_valid(&self) -> TokenStream {
  method gen_from_inner (line 136) | fn gen_from_inner(&self) -> TokenStream {
  method gen_into_record (line 151) | fn gen_into_record(&self) -> TokenStream {
  method gen_load_record (line 165) | fn gen_load_record(&self) -> TokenStream {
  method gen_clone (line 182) | fn gen_clone(&self) -> TokenStream {
  method record_codegen (line 196) | fn record_codegen(self) -> Self::RecordCodegen {
  method module_generics (line 200) | fn module_generics(&self) -> &ModuleGenerics {
  method gen_display (line 204) | fn gen_display(&self) -> TokenStream {

FILE: crates/burn-derive/src/module/codegen_struct.rs
  type StructModuleCodegen (line 12) | pub(crate) struct StructModuleCodegen {
    method from_ast (line 283) | pub fn from_ast(ast: &syn::DeriveInput) -> syn::Result<Self> {
    method gen_fields_fn_names (line 293) | fn gen_fields_fn_names<F>(&self, func: F) -> (Vec<Ident>, TokenStream)
    method gen_fields_fn (line 310) | fn gen_fields_fn<F>(&self, func: F) -> TokenStream
  type RecordCodegen (line 20) | type RecordCodegen = StructModuleRecordCodegen;
  method gen_num_params (line 22) | fn gen_num_params(&self) -> TokenStream {
  method gen_visit (line 42) | fn gen_visit(&self) -> TokenStream {
  method gen_collect_devices (line 65) | fn gen_collect_devices(&self) -> TokenStream {
  method gen_to_device (line 87) | fn gen_to_device(&self) -> TokenStream {
  method gen_fork (line 106) | fn gen_fork(&self) -> TokenStream {
  method gen_map (line 125) | fn gen_map(&self) -> TokenStream {
  method gen_valid (line 149) | fn gen_valid(&self) -> TokenStream {
  method gen_from_inner (line 168) | fn gen_from_inner(&self) -> TokenStream {
  method gen_into_record (line 192) | fn gen_into_record(&self) -> TokenStream {
  method gen_load_record (line 213) | fn gen_load_record(&self) -> TokenStream {
  method gen_clone (line 234) | fn gen_clone(&self) -> TokenStream {
  method record_codegen (line 249) | fn record_codegen(self) -> Self::RecordCodegen {
  method module_generics (line 253) | fn module_generics(&self) -> &ModuleGenerics {
  method gen_display (line 257) | fn gen_display(&self) -> TokenStream {
  type ModuleField (line 325) | pub struct ModuleField {
    method ident (line 331) | pub fn ident(&self) -> Ident {
  type ModuleFieldAttribute (line 337) | pub enum ModuleFieldAttribute {
  type ModuleFieldType (line 342) | pub struct ModuleFieldType {
    method is_parameter_module (line 351) | pub fn is_parameter_module(&self) -> bool {
    method is_persistent_module (line 356) | pub fn is_persistent_module(&self) -> bool {
    method maybe_generic_module (line 361) | pub fn maybe_generic_module(&self) -> bool {
  function parse_module_fields (line 368) | pub(crate) fn parse_module_fields(
  function parse_module_field_type (line 387) | pub(crate) fn parse_module_field_type(
  function type_matches_ident (line 446) | fn type_matches_ident(ty: &syn::Type, idents: &[&str]) -> bool {
  function is_primitive_type (line 456) | fn is_primitive_type(ty: &syn::Type) -> bool {
  function is_tensor_type (line 466) | fn is_tensor_type(ty: &syn::Type) -> bool {
  function is_param_type (line 470) | fn is_param_type(ty: &syn::Type) -> bool {

FILE: crates/burn-derive/src/module/display.rs
  function attributes_fn (line 6) | pub fn attributes_fn(ast: &syn::DeriveInput) -> proc_macro2::TokenStream {
  function display_fn (line 100) | pub fn display_fn(_ast: &syn::DeriveInput) -> proc_macro2::TokenStream {

FILE: crates/burn-derive/src/module/generics.rs
  type GenericKind (line 7) | pub enum GenericKind {
  type ModuleGenerics (line 17) | pub struct ModuleGenerics {
    method is_empty (line 22) | pub fn is_empty(&self) -> bool {
    method get_generic_kind (line 26) | pub fn get_generic_kind(&self, ident: &Ident) -> Option<&GenericKind> {
    method is_bounded_module (line 30) | pub fn is_bounded_module(&self, ident: &Ident) -> bool {
    method update (line 37) | pub fn update(&mut self, ident: &Ident, kind: GenericKind) {
    method contains (line 41) | pub fn contains(&self, ident: &Ident) -> bool {
  function parse_module_generics (line 46) | pub fn parse_module_generics(generics: &Generics) -> ModuleGenerics {
  function has_module_bound (line 88) | fn has_module_bound(
  function has_bound (line 95) | fn has_bound(
  function parse_ty_generics (line 109) | pub fn parse_ty_generics(ty: &Type, declared: &ModuleGenerics) -> HashSe...

FILE: crates/burn-derive/src/module/record.rs
  type ModuleRecordCodegen (line 5) | pub(crate) trait ModuleRecordCodegen {
    method gen_record_type (line 7) | fn gen_record_type(&self, record_name: &Ident, generics: &Generics) ->...

FILE: crates/burn-derive/src/module/record_enum.rs
  type EnumModuleRecordCodegen (line 9) | pub(crate) struct EnumModuleRecordCodegen {
  method gen_record_type (line 15) | fn gen_record_type(&self, record_name: &Ident, generics: &Generics) -> (...

FILE: crates/burn-derive/src/module/record_struct.rs
  type StructModuleRecordCodegen (line 11) | pub(crate) struct StructModuleRecordCodegen {
  method gen_record_type (line 17) | fn gen_record_type(&self, record_name: &Ident, generics: &Generics) -> (...

FILE: crates/burn-derive/src/record/base.rs
  function derive_impl (line 6) | pub(crate) fn derive_impl(ast: &syn::DeriveInput) -> proc_macro::TokenSt...

FILE: crates/burn-derive/src/record/codegen.rs
  function generate_record (line 7) | pub(crate) fn generate_record<G: RecordItemCodegen>(ast: &syn::DeriveInp...
  type RecordCodegen (line 23) | pub(crate) struct RecordCodegen<G: RecordItemCodegen> {
  function gen_record_type (line 32) | pub(crate) fn gen_record_type(&self) -> TokenStream {
  function gen_impl_record (line 47) | pub(crate) fn gen_impl_record(&self) -> TokenStream {
  function impl_generics (line 77) | fn impl_generics(&self) -> Option<TokenStream> {
  function record_item_generics (line 92) | fn record_item_generics(&self) -> Generics {
  function from_ast (line 107) | pub(crate) fn from_ast(ast: &syn::DeriveInput) -> syn::Result<Self> {
  type RecordType (line 116) | struct RecordType {
    method from_ast (line 128) | fn from_ast(ast: &syn::DeriveInput) -> Self {

FILE: crates/burn-derive/src/record/item/codegen.rs
  type RecordItemCodegen (line 5) | pub(crate) trait RecordItemCodegen {
    method from_ast (line 7) | fn from_ast(ast: &syn::DeriveInput) -> syn::Result<Self>
    method gen_item_type (line 11) | fn gen_item_type(
    method gen_into_item (line 18) | fn gen_into_item(&self, item_name: &Ident) -> TokenStream;
    method gen_from_item (line 20) | fn gen_from_item(&self) -> TokenStream;

FILE: crates/burn-derive/src/record/item/codegen_enum.rs
  type EnumRecordItemCodegen (line 8) | pub(crate) struct EnumRecordItemCodegen {
  method from_ast (line 15) | fn from_ast(ast: &syn::DeriveInput) -> syn::Result<Self> {
  method gen_item_type (line 22) | fn gen_item_type(
  method gen_into_item (line 98) | fn gen_into_item(&self, _item_name: &Ident) -> TokenStream {
  method gen_from_item (line 118) | fn gen_from_item(&self) -> TokenStream {

FILE: crates/burn-derive/src/record/item/codegen_struct.rs
  type StructRecordItemCodegen (line 8) | pub(crate) struct StructRecordItemCodegen {
  method from_ast (line 14) | fn from_ast(ast: &syn::DeriveInput) -> syn::Result<Self> {
  method gen_item_type (line 24) | fn gen_item_type(
  method gen_into_item (line 97) | fn gen_into_item(&self, item_name: &Ident) -> TokenStream {
  method gen_from_item (line 117) | fn gen_from_item(&self) -> TokenStream {

FILE: crates/burn-derive/src/shared/attribute.rs
  type AttributeAnalyzer (line 3) | pub struct AttributeAnalyzer {
    method new (line 13) | pub fn new(attr: Attribute) -> Self {
    method item (line 17) | pub fn item(&self) -> AttributeItem {
    method has_name (line 32) | pub fn has_name(&self, name: &str) -> bool {
    method path_syn_name (line 36) | fn path_syn_name(path: &syn::Path) -> String {
  type AttributeItem (line 8) | pub struct AttributeItem {

FILE: crates/burn-derive/src/shared/enum_variant.rs
  function map_enum_variant (line 6) | pub(crate) fn map_enum_variant<Mapper>(
  type EnumVariant (line 54) | pub(crate) struct EnumVariant {
  function parse_variants (line 58) | pub(crate) fn parse_variants(ast: &syn::DeriveInput) -> syn::Result<Vec<...

FILE: crates/burn-derive/src/shared/field.rs
  type FieldTypeAnalyzer (line 6) | pub struct FieldTypeAnalyzer {
    method new (line 11) | pub fn new(field: Field) -> Self {
    method ident (line 15) | pub fn ident(&self) -> Ident {
    method is_of_type (line 19) | pub fn is_of_type(&self, paths: &[&str]) -> bool {
    method first_generic_field (line 30) | pub fn first_generic_field(&self) -> TypePath {
    method path_generic_argument (line 37) | pub fn path_generic_argument(path: &TypePath) -> TypePath {
    method path_name (line 55) | fn path_name(path: &TypePath) -> String {
    method docs (line 70) | pub fn docs(&self) -> impl Iterator<Item = &syn::Attribute> {
    method attributes (line 77) | pub fn attributes(&self) -> impl Iterator<Item = AttributeAnalyzer> {
  function parse_fields (line 86) | pub(crate) fn parse_fields(ast: &syn::DeriveInput) -> Vec<Field> {

FILE: crates/burn-derive/src/shared/generics.rs
  type GenericsHelper (line 6) | pub struct GenericsHelper {
    method add_predicate (line 11) | pub fn add_predicate(&mut self, predicate: WherePredicate) {
    method consts (line 25) | pub fn consts(&self) -> Vec<Ident> {
    method types (line 32) | pub fn types(&self) -> Vec<Ident> {
    method fetch_backend_trait (line 39) | pub fn fetch_backend_trait(&self) -> proc_macro2::TokenStream {

FILE: crates/burn-dispatch/build.rs
  function main (line 1) | fn main() {

FILE: crates/burn-dispatch/src/backend.rs
  type Dispatch (line 42) | pub struct Dispatch;
  type Device (line 45) | type Device = DispatchDevice;
  type FloatTensorPrimitive (line 47) | type FloatTensorPrimitive = DispatchTensor;
  type FloatElem (line 50) | type FloatElem = f32;
  type IntTensorPrimitive (line 52) | type IntTensorPrimitive = DispatchTensor;
  type IntElem (line 54) | type IntElem = i32;
  type BoolTensorPrimitive (line 56) | type BoolTensorPrimitive = DispatchTensor;
  type BoolElem (line 58) | type BoolElem = u8;
  type QuantizedTensorPrimitive (line 60) | type QuantizedTensorPrimitive = DispatchTensor;
  method name (line 62) | fn name(device: &Self::Device) -> String {
  method seed (line 67) | fn seed(device: &Self::Device, seed: u64) {
  method sync (line 71) | fn sync(device: &Self::Device) -> Result<(), ExecutionError> {
  method dtype_usage (line 75) | fn dtype_usage(device: &Self::Device, dtype: DType) -> burn_backend::DTy...
  method ad_enabled (line 79) | fn ad_enabled(device: &Self::Device) -> bool {
  type InnerBackend (line 90) | type InnerBackend = Dispatch;
  type Gradients (line 92) | type Gradients = Gradients;
  method backward (line 94) | fn backward(tensor: DispatchTensor) -> Self::Gradients {
  method grad (line 121) | fn grad(tensor: &DispatchTensor, grads: &Self::Gradients) -> Option<Disp...
  method grad_remove (line 176) | fn grad_remove(tensor: &DispatchTensor, grads: &mut Self::Gradients) -> ...
  method grad_replace (line 231) | fn grad_replace(tensor: &DispatchTensor, grads: &mut Self::Gradients, gr...
  method inner (line 284) | fn inner(tensor: DispatchTensor) -> DispatchTensor {
  method int_inner (line 333) | fn int_inner(tensor: DispatchTensor) -> DispatchTensor {
  method bool_inner (line 337) | fn bool_inner(tensor: DispatchTensor) -> DispatchTensor {
  method q_inner (line 341) | fn q_inner(tensor: DispatchTensor) -> DispatchTensor {
  method from_inner (line 345) | fn from_inner(tensor: DispatchTensor) -> DispatchTensor {
  method int_from_inner (line 404) | fn int_from_inner(tensor: DispatchTensor) -> DispatchTensor {
  method bool_from_inner (line 408) | fn bool_from_inner(tensor: DispatchTensor) -> DispatchTensor {
  method q_from_inner (line 412) | fn q_from_inner(tensor: DispatchTensor) -> DispatchTensor {
  method device (line 418) | pub(crate) fn device(&self) -> DispatchDevice {
  method device (line 443) | pub(crate) fn device(&self) -> DispatchDevice {

FILE: crates/burn-dispatch/src/device.rs
  type DispatchDevice (line 21) | pub enum DispatchDevice {
    method fmt (line 114) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method autodiff (line 210) | pub fn autodiff(device: impl Into<DispatchDevice>) -> DispatchDevice {
    method autodiff_checkpointed (line 215) | pub fn autodiff_checkpointed(
    method backend_id (line 224) | fn backend_id(&self) -> BackendId {
    method encode_type_id (line 248) | fn encode_type_id(&self, backend_type_id: u16) -> u16 {
    method decode_type_id (line 253) | fn decode_type_id(type_id: u16) -> (BackendId, u16) {
    method from_id (line 327) | fn from_id(mut device_id: DeviceId) -> Self {
    method to_id (line 351) | fn to_id(&self) -> DeviceId {
    method device_count (line 376) | fn device_count(type_id: u16) -> usize {
    method from (line 401) | fn from(device: CpuDevice) -> Self {
    method from (line 408) | fn from(device: CudaDevice) -> Self {
    method from (line 415) | fn from(device: WgpuDevice) -> Self {
    method from (line 422) | fn from(device: RocmDevice) -> Self {
    method from (line 429) | fn from(device: WgpuDevice) -> Self {
    method from (line 436) | fn from(device: WgpuDevice) -> Self {
    method from (line 443) | fn from(device: NdArrayDevice) -> Self {
    method from (line 450) | fn from(device: LibTorchDevice) -> Self {
    method from (line 457) | fn from(device: LibTorchDevice) -> Self {
  type AutodiffDevice (line 65) | pub struct AutodiffDevice {
    method new (line 72) | pub(crate) fn new(device: DispatchDevice, checkpointing: Checkpointing...
    type Target (line 83) | type Target = DispatchDevice;
    method deref (line 85) | fn deref(&self) -> &Self::Target {
  type CheckpointingStrategy (line 95) | pub enum CheckpointingStrategy {
  function validate_checkpointing (line 102) | pub(crate) fn validate_checkpointing(
  method default (line 141) | fn default() -> Self {
  method eq (line 171) | fn eq(&self, other: &Self) -> bool {
  constant TYPE_ID_BASE (line 205) | const TYPE_ID_BASE: u16 = 10;
  type BackendId (line 265) | enum BackendId {
    type Error (line 291) | type Error = ();
    method try_from (line 293) | fn try_from(value: u16) -> Result<Self, Self::Error> {
  function from (line 285) | fn from(variant: BackendId) -> Self {
  method inner (line 317) | fn inner(&self) -> &Self {

FILE: crates/burn-dispatch/src/ops/activation.rs
  method leaky_relu (line 7) | fn leaky_relu(tensor: FloatTensor<Self>, negative_slope: Scalar) -> Floa...
  method relu (line 11) | fn relu(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method relu_backward (line 15) | fn relu_backward(output: FloatTensor<Self>, grad: FloatTensor<Self>) -> ...
  method gelu (line 19) | fn gelu(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method prelu (line 23) | fn prelu(tensor: FloatTensor<Self>, alpha: FloatTensor<Self>) -> FloatTe...
  method gelu_backward (line 27) | fn gelu_backward(x: FloatTensor<Self>, grad: FloatTensor<Self>) -> Float...
  method sigmoid (line 31) | fn sigmoid(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method sigmoid_backward (line 35) | fn sigmoid_backward(output: FloatTensor<Self>, grad: FloatTensor<Self>) ...
  method hard_sigmoid (line 39) | fn hard_sigmoid(tensor: FloatTensor<Self>, alpha: Scalar, beta: Scalar) ...
  method log_sigmoid (line 43) | fn log_sigmoid(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method log_sigmoid_backward (line 47) | fn log_sigmoid_backward(x: FloatTensor<Self>, grad: FloatTensor<Self>) -...

FILE: crates/burn-dispatch/src/ops/bool_tensor.rs
  method bool_empty (line 12) | fn bool_empty(shape: Shape, device: &DispatchDevice) -> BoolTensor<Self> {
  method bool_zeros (line 16) | fn bool_zeros(shape: Shape, device: &DispatchDevice) -> BoolTensor<Self> {
  method bool_ones (line 20) | fn bool_ones(shape: Shape, device: &DispatchDevice) -> BoolTensor<Self> {
  method bool_into_data (line 24) | async fn bool_into_data(tensor: BoolTensor<Self>) -> Result<TensorData, ...
  method bool_from_data (line 28) | fn bool_from_data(data: TensorData, device: &DispatchDevice) -> BoolTens...
  method bool_into_int (line 32) | fn bool_into_int(tensor: BoolTensor<Self>) -> IntTensor<Self> {
  method bool_into_float (line 36) | fn bool_into_float(tensor: BoolTensor<Self>) -> FloatTensor<Self> {
  method bool_device (line 40) | fn bool_device(tensor: &BoolTensor<Self>) -> DispatchDevice {
  method bool_to_device (line 44) | fn bool_to_device(tensor: BoolTensor<Self>, device: &DispatchDevice) -> ...
  method bool_reshape (line 59) | fn bool_reshape(tensor: BoolTensor<Self>, shape: Shape) -> BoolTensor<Se...
  method bool_slice (line 63) | fn bool_slice(tensor: BoolTensor<Self>, slices: &[Slice]) -> BoolTensor<...
  method bool_slice_assign (line 67) | fn bool_slice_assign(
  method bool_mask_where (line 75) | fn bool_mask_where(
  method bool_mask_fill (line 86) | fn bool_mask_fill(
  method bool_gather (line 94) | fn bool_gather(
  method bool_scatter_or (line 102) | fn bool_scatter_or(
  method bool_equal (line 114) | fn bool_equal(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTenso...
  method bool_equal_elem (line 118) | fn bool_equal_elem(lhs: BoolTensor<Self>, rhs: Scalar) -> BoolTensor<Sel...
  method bool_not (line 122) | fn bool_not(tensor: BoolTensor<Self>) -> BoolTensor<Self> {
  method bool_and (line 126) | fn bool_and(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTensor<...
  method bool_or (line 130) | fn bool_or(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTensor<S...
  method bool_swap_dims (line 134) | fn bool_swap_dims(tensor: BoolTensor<Self>, dim1: usize, dim2: usize) ->...
  method bool_permute (line 138) | fn bool_permute(tensor: BoolTensor<Self>, axes: &[usize]) -> BoolTensor<...
  method bool_flip (line 142) | fn bool_flip(tensor: BoolTensor<Self>, axes: &[usize]) -> BoolTensor<Sel...
  method bool_expand (line 146) | fn bool_expand(tensor: BoolTensor<Self>, shape: Shape) -> BoolTensor<Sel...
  method bool_unfold (line 150) | fn bool_unfold(
  method bool_select (line 159) | fn bool_select(
  method bool_select_or (line 167) | fn bool_select_or(
  method bool_repeat_dim (line 179) | fn bool_repeat_dim(tensor: BoolTensor<Self>, dim: usize, times: usize) -...
  method bool_cat (line 183) | fn bool_cat(tensors: Vec<BoolTensor<Self>>, dim: usize) -> BoolTensor<Se...
  method bool_not_equal (line 187) | fn bool_not_equal(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolT...
  method bool_not_equal_elem (line 191) | fn bool_not_equal_elem(lhs: BoolTensor<Self>, rhs: Scalar) -> BoolTensor...
  method bool_xor (line 195) | fn bool_xor(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTensor<...
  method bool_transpose (line 199) | fn bool_transpose(tensor: BoolTensor<Self>) -> BoolTensor<Self> {
  method bool_any (line 203) | fn bool_any(tensor: BoolTensor<Self>) -> BoolTensor<Self> {
  method bool_any_dim (line 207) | fn bool_any_dim(tensor: BoolTensor<Self>, dim: usize) -> BoolTensor<Self> {
  method bool_all (line 211) | fn bool_all(tensor: BoolTensor<Self>) -> BoolTensor<Self> {
  method bool_all_dim (line 215) | fn bool_all_dim(tensor: BoolTensor<Self>, dim: usize) -> BoolTensor<Self> {
  method bool_argwhere (line 219) | async fn bool_argwhere(tensor: BoolTensor<Self>) -> IntTensor<Self> {

FILE: crates/burn-dispatch/src/ops/int_tensor.rs
  method int_empty (line 12) | fn int_empty(shape: Shape, device: &DispatchDevice, dtype: IntDType) -> ...
  method int_into_data (line 16) | async fn int_into_data(tensor: IntTensor<Self>) -> Result<TensorData, Ex...
  method int_from_data (line 20) | fn int_from_data(data: TensorData, device: &DispatchDevice) -> IntTensor...
  method int_device (line 24) | fn int_device(tensor: &IntTensor<Self>) -> DispatchDevice {
  method int_to_device (line 28) | fn int_to_device(tensor: IntTensor<Self>, device: &DispatchDevice) -> In...
  method int_reshape (line 35) | fn int_reshape(tensor: IntTensor<Self>, shape: Shape) -> IntTensor<Self> {
  method int_slice (line 39) | fn int_slice(tensor: IntTensor<Self>, slices: &[Slice]) -> IntTensor<Sel...
  method int_slice_assign (line 43) | fn int_slice_assign(
  method int_into_float (line 51) | fn int_into_float(tensor: IntTensor<Self>) -> FloatTensor<Self> {
  method int_mask_where (line 55) | fn int_mask_where(
  method int_mask_fill (line 66) | fn int_mask_fill(
  method int_gather (line 74) | fn int_gather(
  method int_scatter_add (line 82) | fn int_scatter_add(
  method int_select (line 94) | fn int_select(
  method int_select_add (line 102) | fn int_select_add(
  method int_equal (line 114) | fn int_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor<S...
  method int_equal_elem (line 118) | fn int_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Self> {
  method int_greater (line 122) | fn int_greater(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor...
  method int_greater_elem (line 126) | fn int_greater_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Sel...
  method int_greater_equal (line 130) | fn int_greater_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> Bool...
  method int_greater_equal_elem (line 134) | fn int_greater_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTens...
  method int_lower (line 138) | fn int_lower(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor<S...
  method int_lower_elem (line 142) | fn int_lower_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Self> {
  method int_lower_equal (line 146) | fn int_lower_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTe...
  method int_lower_equal_elem (line 150) | fn int_lower_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor...
  method int_add (line 154) | fn int_add(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  method int_add_scalar (line 158) | fn int_add_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  method int_sub (line 162) | fn int_sub(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  method int_sub_scalar (line 166) | fn int_sub_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  method int_mul (line 170) | fn int_mul(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  method int_mul_scalar (line 174) | fn int_mul_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  method int_div (line 178) | fn int_div(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  method int_div_scalar (line 182) | fn int_div_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  method int_remainder (line 186) | fn int_remainder(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTenso...
  method int_remainder_scalar (line 190) | fn int_remainder_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<...
  method int_matmul (line 194) | fn int_matmul(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  method int_sum (line 198) | fn int_sum(tensor: IntTensor<Self>) -> IntTensor<Self> {
  method int_sum_dim (line 202) | fn int_sum_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  method int_prod (line 206) | fn int_prod(tensor: IntTensor<Self>) -> IntTensor<Self> {
  method int_prod_dim (line 210) | fn int_prod_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  method int_mean_dim (line 214) | fn int_mean_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  method int_cumsum (line 218) | fn int_cumsum(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  method int_cumprod (line 222) | fn int_cumprod(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  method int_cummin (line 226) | fn int_cummin(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  method int_cummax (line 230) | fn int_cummax(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  method int_argmax (line 234) | fn int_argmax(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  method int_argmin (line 238) | fn int_argmin(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  method int_abs (line 242) | fn int_abs(tensor: IntTensor<Self>) -> IntTensor<Self> {
  method int_swap_dims (line 246) | fn int_swap_dims(tensor: IntTensor<Self>, dim1: usize, dim2: usize) -> I...
  method int_permute (line 250) | fn int_permute(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Sel...
  method int_flip (line 254) | fn int_flip(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Self> {
  method int_random (line 258) | fn int_random(
  method int_expand (line 268) | fn int_expand(tensor: IntTensor<Self>, shape: Shape) -> IntTensor<Self> {
  method bitwise_and (line 272) | fn bitwise_and(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  method bitwise_and_scalar (line 276) | fn bitwise_and_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  method bitwise_or (line 280) | fn bitwise_or(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  method bitwise_or_scalar (line 284) | fn bitwise_or_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Sel...
  method bitwise_xor (line 288) | fn bitwise_xor(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  method bitwise_xor_scalar (line 292) | fn bitwise_xor_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  method bitwise_not (line 296) | fn bitwise_not(tensor: IntTensor<Self>) -> IntTensor<Self> {
  method bitwise_left_shift (line 300) | fn bitwise_left_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> Int...
  method bitwise_left_shift_scalar (line 304) | fn bitwise_left_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTe...
  method bitwise_right_shift (line 308) | fn bitwise_right_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> In...
  method bitwise_right_shift_scalar (line 312) | fn bitwise_right_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntT...
  method int_cast (line 316) | fn int_cast(tensor: IntTensor<Self>, dtype: IntDType) -> IntTensor<Self> {
  method int_unfold (line 320) | fn int_unfold(
  method int_repeat_dim (line 329) | fn int_repeat_dim(tensor: IntTensor<Self>, dim: usize, times: usize) -> ...
  method int_cat (line 333) | fn int_cat(tensors: Vec<IntTensor<Self>>, dim: usize) -> IntTensor<Self> {
  method int_not_equal (line 337) | fn int_not_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTens...
  method int_not_equal_elem (line 341) | fn int_not_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<S...
  method int_powi (line 345) | fn int_powi(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Sel...
  method int_powi_scalar_impl (line 349) | fn int_powi_scalar_impl(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<...
  method int_clamp_min (line 353) | fn int_clamp_min(tensor: IntTensor<Self>, min: Scalar) -> IntTensor<Self> {
  method int_clamp_max (line 357) | fn int_clamp_max(tensor: IntTensor<Self>, max: Scalar) -> IntTensor<Self> {
  method int_clamp (line 361) | fn int_clamp(tensor: IntTensor<Self>, min: Scalar, max: Scalar) -> IntTe...
  method int_neg (line 365) | fn int_neg(tensor: IntTensor<Self>) -> IntTensor<Self> {
  method int_zeros (line 369) | fn int_zeros(shape: Shape, device: &DispatchDevice, dtype: IntDType) -> ...
  method int_ones (line 373) | fn int_ones(shape: Shape, device: &DispatchDevice, dtype: IntDType) -> I...
  method int_full (line 377) | fn int_full(
  method int_mean (line 388) | fn int_mean(tensor: IntTensor<Self>) -> IntTensor<Self> {
  method int_max (line 392) | fn int_max(tensor: IntTensor<Self>) -> IntTensor<Self> {
  method int_max_dim (line 396) | fn int_max_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  method int_max_dim_with_indices (line 400) | fn int_max_dim_with_indices(
  method int_max_abs (line 411) | fn int_max_abs(tensor: IntTensor<Self>) -> IntTensor<Self> {
  method int_max_abs_dim (line 415) | fn int_max_abs_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Sel...
  method int_min (line 419) | fn int_min(tensor: IntTensor<Self>) -> IntTensor<Self> {
  method int_min_dim (line 423) | fn int_min_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  method int_min_dim_with_indices (line 427) | fn int_min_dim_with_indices(
  method int_transpose (line 438) | fn int_transpose(tensor: IntTensor<Self>) -> IntTensor<Self> {
  method int_arange_step (line 442) | fn int_arange_step(
  method int_arange (line 452) | fn int_arange(range: std::ops::Range<i64>, device: &DispatchDevice) -> I...
  method int_any (line 456) | fn int_any(tensor: IntTensor<Self>) -> BoolTensor<Self> {
  method int_any_dim (line 460) | fn int_any_dim(tensor: IntTensor<Self>, dim: usize) -> BoolTensor<Self> {
  method int_all (line 464) | fn int_all(tensor: IntTensor<Self>) -> BoolTensor<Self> {
  method int_all_dim (line 468) | fn int_all_dim(tensor: IntTensor<Self>, dim: usize) -> BoolTensor<Self> {
  method int_sign (line 472) | fn int_sign(tensor: IntTensor<Self>) -> IntTensor<Self> {
  method int_sort (line 476) | fn int_sort(tensor: IntTensor<Self>, dim: usize, descending: bool) -> In...
  method int_sort_with_indices (line 480) | fn int_sort_with_indices(
  method int_argsort (line 492) | fn int_argsort(tensor: IntTensor<Self>, dim: usize, descending: bool) ->...

FILE: crates/burn-dispatch/src/ops/module.rs
  method conv2d (line 13) | fn conv2d(
  method deform_conv2d (line 27) | fn deform_conv2d(
  method deform_conv2d_backward (line 43) | fn deform_conv2d_backward(
  method conv3d (line 65) | fn conv3d(
  method conv_transpose2d (line 79) | fn conv_transpose2d(
  method conv_transpose3d (line 93) | fn conv_transpose3d(
  method avg_pool2d (line 107) | fn avg_pool2d(
  method avg_pool2d_backward (line 121) | fn avg_pool2d_backward(
  method adaptive_avg_pool2d (line 137) | fn adaptive_avg_pool2d(x: FloatTensor<Self>, output_size: [usize; 2]) ->...
  method adaptive_avg_pool2d_backward (line 145) | fn adaptive_avg_pool2d_backward(
  method max_pool2d (line 156) | fn max_pool2d(
  method max_pool2d_with_indices (line 171) | fn max_pool2d_with_indices(
  method max_pool2d_with_indices_backward (line 190) | fn max_pool2d_with_indices_backward(
  method interpolate (line 211) | fn interpolate(
  method interpolate_backward (line 223) | fn interpolate_backward(
  method embedding (line 236) | fn embedding(weights: FloatTensor<Self>, indices: IntTensor<Self>) -> Fl...
  method embedding_backward (line 244) | fn embedding_backward(
  method conv1d (line 256) | fn conv1d(
  method conv1d_x_backward (line 270) | fn conv1d_x_backward(
  method conv1d_weight_backward (line 283) | fn conv1d_weight_backward(
  method conv1d_bias_backward (line 296) | fn conv1d_bias_backward(
  method conv2d_x_backward (line 308) | fn conv2d_x_backward(
  method conv2d_weight_backward (line 321) | fn conv2d_weight_backward(
  method conv2d_bias_backward (line 334) | fn conv2d_bias_backward(
  method conv3d_x_backward (line 346) | fn conv3d_x_backward(
  method conv3d_weight_backward (line 359) | fn conv3d_weight_backward(
  method conv3d_bias_backward (line 372) | fn conv3d_bias_backward(
  method conv_transpose1d (line 384) | fn conv_transpose1d(
  method conv_transpose1d_x_backward (line 398) | fn conv_transpose1d_x_backward(
  method conv_transpose1d_weight_backward (line 410) | fn conv_transpose1d_weight_backward(
  method conv_transpose1d_bias_backward (line 423) | fn conv_transpose1d_bias_backward(
  method conv_transpose2d_x_backward (line 435) | fn conv_transpose2d_x_backward(
  method conv_transpose2d_weight_backward (line 447) | fn conv_transpose2d_weight_backward(
  method conv_transpose2d_bias_backward (line 460) | fn conv_transpose2d_bias_backward(
  method conv_transpose3d_x_backward (line 472) | fn conv_transpose3d_x_backward(
  method conv_transpose3d_weight_backward (line 484) | fn conv_transpose3d_weight_backward(
  method conv_transpose3d_bias_backward (line 497) | fn conv_transpose3d_bias_backward(
  method unfold4d (line 509) | fn unfold4d(
  method avg_pool1d (line 517) | fn avg_pool1d(
  method avg_pool1d_backward (line 530) | fn avg_pool1d_backward(
  method adaptive_avg_pool1d (line 546) | fn adaptive_avg_pool1d(x: FloatTensor<Self>, output_size: usize) -> Floa...
  method adaptive_avg_pool1d_backward (line 550) | fn adaptive_avg_pool1d_backward(
  method max_pool1d (line 561) | fn max_pool1d(
  method max_pool1d_with_indices (line 573) | fn max_pool1d_with_indices(
  method max_pool1d_with_indices_backward (line 592) | fn max_pool1d_with_indices_backward(
  method attention (line 613) | fn attention(

FILE: crates/burn-dispatch/src/ops/qtensor.rs
  method q_from_data (line 13) | fn q_from_data(data: TensorData, device: &DispatchDevice) -> QuantizedTe...
  method quantize (line 17) | fn quantize(
  method dequantize (line 31) | fn dequantize(tensor: QuantizedTensor<Self>) -> FloatTensor<Self> {
  method q_device (line 35) | fn q_device(tensor: &QuantizedTensor<Self>) -> DispatchDevice {
  method q_to_device (line 39) | fn q_to_device(
  method q_reshape (line 57) | fn q_reshape(tensor: QuantizedTensor<Self>, shape: Shape) -> QuantizedTe...
  method q_into_data (line 61) | async fn q_into_data(tensor: QuantizedTensor<Self>) -> Result<TensorData...
  method q_expand (line 65) | fn q_expand(tensor: QuantizedTensor<Self>, shape: Shape) -> QuantizedTen...
  method q_swap_dims (line 69) | fn q_swap_dims(
  method q_permute (line 77) | fn q_permute(tensor: QuantizedTensor<Self>, axes: &[usize]) -> Quantized...
  method q_flip (line 81) | fn q_flip(tensor: QuantizedTensor<Self>, axes: &[usize]) -> QuantizedTen...
  method q_select (line 85) | fn q_select(
  method q_slice (line 97) | fn q_slice(tensor: QuantizedTensor<Self>, slices: &[Slice]) -> Quantized...
  method q_matmul (line 101) | fn q_matmul(lhs: TensorPrimitive<Self>, rhs: TensorPrimitive<Self>) -> T...

FILE: crates/burn-dispatch/src/ops/tensor.rs
  method float_from_data (line 15) | fn float_from_data(
  method float_random (line 22) | fn float_random(
  method float_into_data (line 32) | async fn float_into_data(tensor: FloatTensor<Self>) -> Result<TensorData...
  method float_device (line 36) | fn float_device(tensor: &FloatTensor<Self>) -> DispatchDevice {
  method float_to_device (line 40) | fn float_to_device(tensor: FloatTensor<Self>, device: &DispatchDevice) -...
  method float_into_int (line 55) | fn float_into_int(tensor: FloatTensor<Self>) -> IntTensor<Self> {
  method float_empty (line 59) | fn float_empty(shape: Shape, device: &DispatchDevice, dtype: FloatDType)...
  method float_add (line 63) | fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  method float_add_scalar (line 67) | fn float_add_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  method float_sub (line 71) | fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  method float_sub_scalar (line 75) | fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  method float_mul (line 79) | fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  method float_mul_scalar (line 83) | fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  method float_div (line 87) | fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  method float_div_scalar (line 91) | fn float_div_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  method float_remainder (line 95) | fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Fl...
  method float_remainder_scalar (line 99) | fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatT...
  method float_matmul (line 103) | fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Float...
  method float_cross (line 107) | fn float_cross(
  method float_recip (line 115) | fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_swap_dims (line 119) | fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) ...
  method float_permute (line 123) | fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTens...
  method float_flip (line 127) | fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<...
  method float_reshape (line 131) | fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor...
  method float_gather (line 135) | fn float_gather(
  method float_scatter_add (line 143) | fn float_scatter_add(
  method float_select (line 155) | fn float_select(
  method float_select_add (line 163) | fn float_select_add(
  method float_slice (line 175) | fn float_slice(tensor: FloatTensor<Self>, slices: &[Slice]) -> FloatTens...
  method float_slice_assign (line 179) | fn float_slice_assign(
  method float_mask_where (line 187) | fn float_mask_where(
  method float_mask_fill (line 198) | fn float_mask_fill(
  method float_equal (line 206) | fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTe...
  method float_equal_elem (line 210) | fn float_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor<S...
  method float_greater (line 214) | fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Bool...
  method float_greater_elem (line 218) | fn float_greater_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor...
  method float_greater_equal (line 222) | fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -...
  method float_greater_equal_elem (line 226) | fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> Bool...
  method float_lower (line 230) | fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTe...
  method float_lower_elem (line 234) | fn float_lower_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor<S...
  method float_lower_equal (line 238) | fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> ...
  method float_lower_equal_elem (line 242) | fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTe...
  method float_sum (line 246) | fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_sum_dim (line 250) | fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  method float_mean_dim (line 254) | fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<...
  method float_cumsum (line 258) | fn float_cumsum(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  method float_cumprod (line 262) | fn float_cumprod(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  method float_cummin (line 266) | fn float_cummin(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  method float_cummax (line 270) | fn float_cummax(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  method float_cast (line 274) | fn float_cast(tensor: FloatTensor<Self>, dtype: FloatDType) -> FloatTens...
  method float_exp (line 278) | fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_log (line 282) | fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_log1p (line 286) | fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_powf (line 290) | fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTe...
  method float_powf_scalar_impl (line 294) | fn float_powf_scalar_impl(tensor: FloatTensor<Self>, value: Scalar) -> F...
  method float_sqrt (line 298) | fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_abs (line 302) | fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_cos (line 306) | fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_sin (line 310) | fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_tan (line 314) | fn float_tan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_cosh (line 318) | fn float_cosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_sinh (line 322) | fn float_sinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_tanh (line 326) | fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_acos (line 330) | fn float_acos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_acosh (line 334) | fn float_acosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_asin (line 338) | fn float_asin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_asinh (line 342) | fn float_asinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_atan (line 346) | fn float_atan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_atanh (line 350) | fn float_atanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_atan2 (line 354) | fn float_atan2(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatT...
  method float_round (line 358) | fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_floor (line 362) | fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_ceil (line 366) | fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_trunc (line 370) | fn float_trunc(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_erf (line 374) | fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_argmax (line 378) | fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {
  method float_argmin (line 382) | fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {
  method float_expand (line 386) | fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<...
  method float_unfold (line 390) | fn float_unfold(
  method float_detach (line 401) | fn float_detach(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_set_require_grad (line 405) | fn float_set_require_grad(tensor: FloatTensor<Self>, require_grad: bool)...
  method float_is_require_grad (line 409) | fn float_is_require_grad(tensor: &FloatTensor<Self>) -> bool {
  method float_zeros (line 414) | fn float_zeros(shape: Shape, device: &DispatchDevice, dtype: FloatDType)...
  method float_ones (line 418) | fn float_ones(shape: Shape, device: &DispatchDevice, dtype: FloatDType) ...
  method float_full (line 422) | fn float_full(
  method float_repeat_dim (line 433) | fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize)...
  method float_clamp_min (line 437) | fn float_clamp_min(tensor: FloatTensor<Self>, min: Scalar) -> FloatTenso...
  method float_clamp_max (line 441) | fn float_clamp_max(tensor: FloatTensor<Self>, max: Scalar) -> FloatTenso...
  method float_clamp (line 445) | fn float_clamp(tensor: FloatTensor<Self>, min: Scalar, max: Scalar) -> F...
  method float_neg (line 449) | fn float_neg(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_transpose (line 453) | fn float_transpose(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_not_equal (line 457) | fn float_not_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Bo...
  method float_not_equal_elem (line 461) | fn float_not_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTens...
  method float_prod (line 465) | fn float_prod(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_prod_dim (line 469) | fn float_prod_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<...
  method float_mean (line 473) | fn float_mean(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_powi (line 477) | fn float_powi(lhs: FloatTensor<Self>, rhs: IntTensor<Self>) -> FloatTens...
  method float_powi_scalar_impl (line 481) | fn float_powi_scalar_impl(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatT...
  method float_powf_scalar (line 485) | fn float_powf_scalar(tensor: FloatTensor<Self>, value: Scalar) -> FloatT...
  method float_cat (line 489) | fn float_cat(tensors: Vec<FloatTensor<Self>>, dim: usize) -> FloatTensor...
  method float_max (line 493) | fn float_max(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_max_dim (line 497) | fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  method float_max_dim_with_indices (line 501) | fn float_max_dim_with_indices(
  method float_min (line 512) | fn float_min(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_min_dim (line 516) | fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  method float_min_dim_with_indices (line 520) | fn float_min_dim_with_indices(
  method float_max_abs (line 531) | fn float_max_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_max_abs_dim (line 535) | fn float_max_abs_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTens...
  method float_any (line 539) | fn float_any(tensor: FloatTensor<Self>) -> BoolTensor<Self> {
  method float_any_dim (line 543) | fn float_any_dim(tensor: FloatTensor<Self>, dim: usize) -> BoolTensor<Se...
  method float_all (line 547) | fn float_all(tensor: FloatTensor<Self>) -> BoolTensor<Self> {
  method float_all_dim (line 551) | fn float_all_dim(tensor: FloatTensor<Self>, dim: usize) -> BoolTensor<Se...
  method float_sign (line 555) | fn float_sign(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  method float_sort (line 559) | fn float_sort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -...
  method float_sort_with_indices (line 563) | fn float_sort_with_indices(
  method float_argsort (line 575) | fn float_argsort(tensor: FloatTensor<Self>, dim: usize, descending: bool...
  method float_grid_sample_2d (line 579) | fn float_grid_sample_2d(
  method float_is_nan (line 587) | fn float_is_nan(tensor: FloatTensor<Self>) -> BoolTensor<Self> {
  method float_is_inf (line 591) | fn float_is_inf(tensor: FloatTensor<Self>) -> BoolTensor<Self> {

FILE: crates/burn-dispatch/src/ops/transaction.rs
  method tr_execute (line 10) | async fn tr_execute(

FILE: crates/burn-dispatch/src/tensor.rs
  type BackendTensor (line 15) | pub enum BackendTensor<B: Backend> {
  function float (line 31) | pub(crate) fn float(self) -> B::FloatTensorPrimitive {
  function as_float (line 42) | pub(crate) fn as_float(&self) -> &B::FloatTensorPrimitive {
  function int (line 54) | pub(crate) fn int(self) -> B::IntTensorPrimitive {
  function bool (line 66) | pub(crate) fn bool(self) -> B::BoolTensorPrimitive {
  function quantized (line 78) | pub(crate) fn quantized(self) -> B::QuantizedTensorPrimitive {
  function autodiff (line 87) | pub(crate) fn autodiff(self) -> FloatTensor<Autodiff<B>> {
  function as_autodiff (line 97) | pub(crate) fn as_autodiff(&self) -> &FloatTensor<Autodiff<B>> {
  function autodiff_inner (line 106) | pub(crate) fn autodiff_inner(self) -> B::FloatTensorPrimitive {
  function device (line 114) | pub(crate) fn device(&self) -> B::Device {
  method dtype (line 127) | fn dtype(&self) -> burn_std::DType {
  method shape (line 138) | fn shape(&self) -> burn_std::Shape {
  method scheme (line 151) | fn scheme(&self) -> &burn_std::QuantScheme {
  type DispatchTensor (line 168) | pub struct DispatchTensor {
  type DispatchTensorKind (line 184) | pub enum DispatchTensorKind {
  method dtype (line 223) | fn dtype(&self) -> burn_std::DType {
  method shape (line 246) | fn shape(&self) -> burn_std::Shape {
  method scheme (line 271) | fn scheme(&self) -> &burn_std::QuantScheme {
  method dtype (line 296) | fn dtype(&self) -> burn_std::DType {
  method shape (line 300) | fn shape(&self) -> burn_std::Shape {
  method scheme (line 306) | fn scheme(&self) -> &burn_std::QuantScheme {

FILE: crates/burn-fusion/src/backend.rs
  function get_client (line 15) | pub fn get_client<B: FusionBackend>(device: &Device<B>) -> Client<B::Fus...
  type Fusion (line 21) | pub struct Fusion<B: FusionBackend> {
  type Device (line 26) | type Device = B::Device;
  type FloatTensorPrimitive (line 28) | type FloatTensorPrimitive = FusionTensor<B::FusionRuntime>;
  type FloatElem (line 30) | type FloatElem = B::FloatElem;
  type IntTensorPrimitive (line 32) | type IntTensorPrimitive = FusionTensor<B::FusionRuntime>;
  type IntElem (line 34) | type IntElem = B::IntElem;
  type BoolTensorPrimitive (line 36) | type BoolTensorPrimitive = FusionTensor<B::FusionRuntime>;
  type BoolElem (line 38) | type BoolElem = B::BoolElem;
  type QuantizedTensorPrimitive (line 40) | type QuantizedTensorPrimitive = FusionTensor<B::FusionRuntime>;
  method name (line 42) | fn name(device: &Self::Device) -> String {
  method seed (line 46) | fn seed(device: &B::Device, seed: u64) {
  method sync (line 52) | fn sync(device: &Self::Device) -> Result<(), ExecutionError> {
  method ad_enabled (line 58) | fn ad_enabled(_device: &Self::Device) -> bool {
  method memory_persistent_allocations (line 62) | fn memory_persistent_allocations<
  method memory_cleanup (line 74) | fn memory_cleanup(device: &Self::Device) {
  method staging (line 78) | fn staging<'a, Iter>(data: Iter, device: &Self::Device)
  method supports_dtype (line 85) | fn supports_dtype(device: &Self::Device, dtype: DType) -> bool {
  method dtype_usage (line 89) | fn dtype_usage(device: &Self::Device, dtype: DType) -> burn_backend::DTy...
  type FuserStatus (line 96) | pub enum FuserStatus {
  type FuserProperties (line 105) | pub struct FuserProperties {
  type OperationFuser (line 124) | pub trait OperationFuser<O>: Send {
    method fuse (line 126) | fn fuse(&mut self, operation: &OperationIr);
    method finish (line 128) | fn finish(&mut self) -> O;
    method reset (line 130) | fn reset(&mut self);
    method status (line 132) | fn status(&self) -> FuserStatus;
    method properties (line 134) | fn properties(&self) -> FuserProperties;
    method len (line 136) | fn len(&self) -> usize;
    method is_empty (line 138) | fn is_empty(&self) -> bool {
    method clone_dyn (line 142) | fn clone_dyn(&self) -> Box<dyn OperationFuser<O>>;
  type NumOperations (line 146) | pub trait NumOperations: core::fmt::Debug {
    method len (line 148) | fn len(&self) -> usize;
    method is_empty (line 150) | fn is_empty(&self) -> bool {
  type Optimization (line 156) | pub trait Optimization<R: FusionRuntime>: Send + NumOperations {
    method execute (line 158) | fn execute(
    method to_state (line 165) | fn to_state(&self) -> R::OptimizationState;
    method from_state (line 167) | fn from_state(device: &R::FusionDevice, state: R::OptimizationState) -...
  type FusionDevice (line 171) | pub type FusionDevice<R> = <R as FusionRuntime>::FusionDevice;
  type FusionHandle (line 173) | pub type FusionHandle<R> = <R as FusionRuntime>::FusionHandle;
  type Client (line 175) | pub type Client<R> = GlobalFusionClient<R>;
  type FusionRuntime (line 178) | pub trait FusionRuntime: Send + Sync + Sized + core::fmt::Debug + 'static {
    method fusers (line 189) | fn fusers(device: Self::FusionDevice) -> Vec<Box<dyn OperationFuser<Se...
  type FusionBackend (line 194) | pub trait FusionBackend:
    method cast_float (line 201) | fn cast_float(tensor: FloatTensor<Self>, dtype: DType) -> Self::Handle;
  type Handle (line 209) | type Handle = FusionTensor<B::FusionRuntime>;
  method float_tensor (line 211) | fn float_tensor(handle: TensorHandle<Self::Handle>) -> FloatTensor<Self> {
  method int_tensor (line 215) | fn int_tensor(handle: TensorHandle<Self::Handle>) -> IntTensor<Self> {
  method bool_tensor (line 219) | fn bool_tensor(handle: TensorHandle<Self::Handle>) -> BoolTensor<Self> {
  method quantized_tensor (line 223) | fn quantized_tensor(handle: TensorHandle<Self::Handle>) -> QuantizedTens...
  method float_tensor_handle (line 227) | fn float_tensor_handle(tensor: FloatTensor<Self>) -> Self::Handle {
  method int_tensor_handle (line 231) | fn int_tensor_handle(tensor: IntTensor<Self>) -> Self::Handle {
  method bool_tensor_handle (line 235) | fn bool_tensor_handle(tensor: BoolTensor<Self>) -> Self::Handle {
  method quantized_tensor_handle (line 239) | fn quantized_tensor_handle(tensor: QuantizedTensor<Self>) -> Self::Handle {
  function bool_dtype (line 246) | pub(crate) fn bool_dtype<BT: burn_backend::Element>() -> DType {

FILE: crates/burn-fusion/src/client.rs
  type GlobalFusionClient (line 14) | pub struct GlobalFusionClient<R: FusionRuntime> {
  method init (line 20) | fn init(device_id: DeviceId) -> Self {
  method utilities (line 25) | fn utilities(&self) -> burn_backend::ServerUtilitiesHandle {
  method clone (line 34) | fn clone(&self) -> Self {
  function load (line 46) | pub fn load(device: &FusionDevice<R>) -> Self {
  function new (line 61) | pub fn new(device: FusionDevice<R>) -> Self {
  function register (line 71) | pub fn register<O>(
  function drain (line 102) | pub fn drain(&self) {
  function create_empty_handle (line 108) | pub fn create_empty_handle(&self) -> TensorId {
  function device (line 114) | pub fn device(&self) -> &FusionDevice<R> {
  function register_tensor_handle (line 119) | pub fn register_tensor_handle(&self, handle: FusionHandle<R>) -> TensorId {
  function read_tensor_float (line 129) | pub fn read_tensor_float<B>(
  function read_tensor_int (line 143) | pub fn read_tensor_int<B>(
  function read_tensor_bool (line 157) | pub fn read_tensor_bool<B>(
  function read_tensor_quantized (line 171) | pub fn read_tensor_quantized<B>(
  function change_client_float (line 185) | pub fn change_client_float<B>(
  function change_client_int (line 220) | pub fn change_client_int<B>(
  function change_client_bool (line 249) | pub fn change_client_bool<B>(
  function change_client_quantized (line 284) | pub fn change_client_quantized<B>(
  function resolve_tensor_float (line 313) | pub fn resolve_tensor_float<B>(&self, tensor: FusionTensor<R>) -> B::Flo...
  function resolve_tensor_int (line 326) | pub fn resolve_tensor_int<B>(&self, tensor: FusionTensor<R>) -> B::IntTe...
  function resolve_tensor_bool (line 339) | pub fn resolve_tensor_bool<B>(&self, tensor: FusionTensor<R>) -> B::Bool...

FILE: crates/burn-fusion/src/ops/base.rs
  type NoOp (line 9) | pub struct NoOp<B: FusionBackend> {
  function execute (line 14) | fn execute(&self, _handles: &mut HandleContainer<B::Handle>) {}

FILE: crates/burn-fusion/src/ops/bool_tensor.rs
  function bool_empty (line 21) | fn bool_empty(shape: Shape, device: &Device<Self>) -> BoolTensor<Self> {
  function bool_zeros (line 49) | fn bool_zeros(shape: Shape, device: &Device<Self>) -> BoolTensor<Self> {
  function bool_ones (line 77) | fn bool_ones(shape: Shape, device: &Device<Self>) -> BoolTensor<Self> {
  function bool_into_data (line 105) | async fn bool_into_data(tensor: BoolTensor<Self>) -> Result<TensorData, ...
  function bool_from_data (line 109) | fn bool_from_data(data: burn_backend::TensorData, device: &Device<Self>)...
  function bool_into_int (line 128) | fn bool_into_int(tensor: BoolTensor<Self>) -> IntTensor<Self> {
  function bool_into_float (line 159) | fn bool_into_float(tensor: BoolTensor<Self>) -> FloatTensor<Self> {
  function bool_device (line 190) | fn bool_device(tensor: &BoolTensor<Self>) -> Device<Self> {
  function bool_to_device (line 194) | fn bool_to_device(tensor: BoolTensor<Self>, device: &Device<Self>) -> Bo...
  function bool_reshape (line 210) | fn bool_reshape(tensor: BoolTensor<Self>, shape: Shape) -> BoolTensor<Se...
  function bool_slice (line 243) | fn bool_slice(tensor: BoolTensor<Self>, slices: &[Slice]) -> BoolTensor<...
  function bool_slice_assign (line 276) | fn bool_slice_assign(
  function bool_cat (line 315) | fn bool_cat(tensors: Vec<BoolTensor<Self>>, dim: usize) -> BoolTensor<Se...
  function bool_equal (line 352) | fn bool_equal(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTenso...
  function bool_not (line 384) | fn bool_not(tensor: BoolTensor<Self>) -> BoolTensor<Self> {
  function bool_and (line 413) | fn bool_and(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTensor<...
  function bool_or (line 445) | fn bool_or(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTensor<S...
  function bool_swap_dims (line 476) | fn bool_swap_dims(tensor: BoolTensor<Self>, dim1: usize, dim2: usize) ->...
  function bool_permute (line 507) | fn bool_permute(tensor: BoolTensor<Self>, axes: &[usize]) -> BoolTensor<...
  function bool_expand (line 538) | fn bool_expand(tensor: BoolTensor<Self>, shape: Shape) -> BoolTensor<Sel...
  function bool_flip (line 568) | fn bool_flip(tensor: BoolTensor<Self>, axes: &[usize]) -> BoolTensor<Sel...
  function bool_repeat_dim (line 599) | fn bool_repeat_dim(tensor: BoolTensor<Self>, dim: usize, times: usize) -...
  function bool_unfold (line 632) | fn bool_unfold(
  function bool_mask_where (line 669) | fn bool_mask_where(
  function bool_mask_fill (line 708) | fn bool_mask_fill(
  function bool_gather (line 747) | fn bool_gather(
  function bool_scatter_or (line 784) | fn bool_scatter_or(
  function bool_equal_elem (line 829) | fn bool_equal_elem(lhs: BoolTensor<Self>, rhs: Scalar) -> BoolTensor<Sel...

FILE: crates/burn-fusion/src/ops/int_tensor.rs
  function int_empty (line 17) | fn int_empty(shape: Shape, device: &Device<Self>, dtype: IntDType) -> In...
  function int_into_data (line 47) | async fn int_into_data(tensor: IntTensor<Self>) -> Result<TensorData, Ex...
  function int_from_data (line 51) | fn int_from_data(data: TensorData, device: &Device<Self>) -> IntTensor<S...
  function int_device (line 69) | fn int_device(tensor: &IntTensor<Self>) -> Device<Self> {
  function int_to_device (line 73) | fn int_to_device(tensor: IntTensor<Self>, device: &Device<Self>) -> IntT...
  function int_reshape (line 89) | fn int_reshape(tensor: IntTensor<Self>, shape: Shape) -> IntTensor<Self> {
  function int_slice (line 122) | fn int_slice(tensor: IntTensor<Self>, slices: &[Slice]) -> IntTensor<Sel...
  function int_slice_assign (line 155) | fn int_slice_assign(
  function int_matmul (line 194) | fn int_matmul(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  function int_mask_where (line 213) | fn int_mask_where(
  function int_mask_fill (line 252) | fn int_mask_fill(
  function int_gather (line 291) | fn int_gather(
  function int_scatter_add (line 328) | fn int_scatter_add(
  function int_select (line 373) | fn int_select(
  function int_select_add (line 411) | fn int_select_add(
  function int_cat (line 456) | fn int_cat(tensors: Vec<IntTensor<Self>>, dim: usize) -> IntTensor<Self> {
  function int_equal (line 493) | fn int_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor<S...
  function int_equal_elem (line 515) | fn int_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Self> {
  function int_greater (line 536) | fn int_greater(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor...
  function int_greater_elem (line 558) | fn int_greater_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Sel...
  function int_greater_equal (line 582) | fn int_greater_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> Bool...
  function int_greater_equal_elem (line 607) | fn int_greater_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTens...
  function int_lower (line 631) | fn int_lower(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor<S...
  function int_lower_elem (line 653) | fn int_lower_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Self> {
  function int_lower_equal (line 677) | fn int_lower_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTe...
  function int_lower_equal_elem (line 702) | fn int_lower_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor...
  function int_add (line 726) | fn int_add(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_add_scalar (line 745) | fn int_add_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_sub (line 766) | fn int_sub(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_sub_scalar (line 785) | fn int_sub_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_mul (line 806) | fn int_mul(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_mul_scalar (line 825) | fn int_mul_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_div (line 846) | fn int_div(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_div_scalar (line 865) | fn int_div_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_remainder (line 886) | fn int_remainder(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTenso...
  function int_remainder_scalar (line 905) | fn int_remainder_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<...
  function int_zeros (line 926) | fn int_zeros(shape: Shape, device: &Device<Self>, dtype: IntDType) -> In...
  function int_ones (line 953) | fn int_ones(shape: Shape, device: &Device<Self>, dtype: IntDType) -> Int...
  function int_full (line 979) | fn int_full(
  function int_sum (line 1015) | fn int_sum(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_sum_dim (line 1032) | fn int_sum_dim(tensor: IntTensor<Self>, axis: usize) -> IntTensor<Self> {
  function int_prod (line 1049) | fn int_prod(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_prod_dim (line 1066) | fn int_prod_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_mean (line 1083) | fn int_mean(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_mean_dim (line 1100) | fn int_mean_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cumsum (line 1117) | fn int_cumsum(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cumprod (line 1146) | fn int_cumprod(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cummin (line 1175) | fn int_cummin(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cummax (line 1204) | fn int_cummax(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_argmax (line 1233) | fn int_argmax(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_argmin (line 1250) | fn int_argmin(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_clamp (line 1267) | fn int_clamp(tensor: IntTensor<Self>, min: Scalar, max: Scalar) -> IntTe...
  function int_abs (line 1299) | fn int_abs(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_into_float (line 1316) | fn int_into_float(tensor: IntTensor<Self>) -> FloatTensor<Self> {
  function int_swap_dims (line 1347) | fn int_swap_dims(tensor: IntTensor<Self>, dim1: usize, dim2: usize) -> I...
  function int_max (line 1377) | fn int_max(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_max_dim (line 1394) | fn int_max_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_max_dim_with_indices (line 1411) | fn int_max_dim_with_indices(
  function int_min (line 1449) | fn int_min(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_max_abs (line 1466) | fn int_max_abs(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_max_abs_dim (line 1483) | fn int_max_abs_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Sel...
  function int_min_dim (line 1503) | fn int_min_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_min_dim_with_indices (line 1520) | fn int_min_dim_with_indices(
  function int_random (line 1558) | fn int_random(
  function int_permute (line 1590) | fn int_permute(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Sel...
  function int_expand (line 1621) | fn int_expand(tensor: IntTensor<Self>, shape: Shape) -> IntTensor<Self> {
  function int_flip (line 1650) | fn int_flip(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Self> {
  function int_repeat_dim (line 1682) | fn int_repeat_dim(tensor: IntTensor<Self>, dim: usize, times: usize) -> ...
  function bitwise_and (line 1715) | fn bitwise_and(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  function bitwise_and_scalar (line 1734) | fn bitwise_and_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  function bitwise_or (line 1752) | fn bitwise_or(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  function bitwise_or_scalar (line 1771) | fn bitwise_or_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Sel...
  function bitwise_xor (line 1789) | fn bitwise_xor(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  function bitwise_xor_scalar (line 1808) | fn bitwise_xor_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  function bitwise_not (line 1826) | fn bitwise_not(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function bitwise_left_shift (line 1843) | fn bitwise_left_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> Int...
  function bitwise_left_shift_scalar (line 1862) | fn bitwise_left_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTe...
  function bitwise_right_shift (line 1880) | fn bitwise_right_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> In...
  function bitwise_right_shift_scalar (line 1899) | fn bitwise_right_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntT...
  function int_cast (line 1917) | fn int_cast(tensor: IntTensor<Self>, dtype: burn_backend::IntDType) -> I...
  function int_unfold (line 1949) | fn int_unfold(

FILE: crates/burn-fusion/src/ops/module.rs
  function conv1d (line 35) | fn conv1d(
  function conv1d_x_backward (line 78) | fn conv1d_x_backward(
  function conv1d_weight_backward (line 117) | fn conv1d_weight_backward(
  function conv1d_bias_backward (line 156) | fn conv1d_bias_backward(
  function conv2d (line 192) | fn conv2d(
  function conv2d_x_backward (line 237) | fn conv2d_x_backward(
  function conv2d_weight_backward (line 276) | fn conv2d_weight_backward(
  function conv2d_bias_backward (line 315) | fn conv2d_bias_backward(
  function deform_conv2d (line 351) | fn deform_conv2d(
  function deform_conv2d_backward (line 409) | fn deform_conv2d_backward(
  function conv3d (line 500) | fn conv3d(
  function conv3d_x_backward (line 545) | fn conv3d_x_backward(
  function conv3d_weight_backward (line 584) | fn conv3d_weight_backward(
  function conv3d_bias_backward (line 623) | fn conv3d_bias_backward(
  function conv_transpose1d (line 659) | fn conv_transpose1d(
  function conv_transpose2d (line 704) | fn conv_transpose2d(
  function conv_transpose3d (line 749) | fn conv_transpose3d(
  function avg_pool1d (line 794) | fn avg_pool1d(
  function avg_pool2d (line 841) | fn avg_pool2d(
  function avg_pool1d_backward (line 889) | fn avg_pool1d_backward(
  function avg_pool2d_backward (line 941) | fn avg_pool2d_backward(
  function max_pool1d (line 993) | fn max_pool1d(
  function max_pool2d (line 1041) | fn max_pool2d(
  function max_pool1d_with_indices (line 1089) | fn max_pool1d_with_indices(
  function max_pool2d_with_indices (line 1141) | fn max_pool2d_with_indices(
  function max_pool1d_with_indices_backward (line 1193) | fn max_pool1d_with_indices_backward(
  function max_pool2d_with_indices_backward (line 1253) | fn max_pool2d_with_indices_backward(
  function adaptive_avg_pool1d (line 1313) | fn adaptive_avg_pool1d(x: FloatTensor<Self>, output_size: usize) -> Floa...
  function adaptive_avg_pool2d (line 1341) | fn adaptive_avg_pool2d(x: FloatTensor<Self>, output_size: [usize; 2]) ->...
  function adaptive_avg_pool1d_backward (line 1369) | fn adaptive_avg_pool1d_backward(
  function adaptive_avg_pool2d_backward (line 1401) | fn adaptive_avg_pool2d_backward(
  function interpolate (line 1432) | fn interpolate(
  function interpolate_backward (line 1463) | fn interpolate_backward(
  function attention (line 1502) | fn attention(

FILE: crates/burn-fusion/src/ops/qtensor.rs
  function q_from_data (line 23) | fn q_from_data(data: TensorData, device: &Device<Self>) -> QuantizedTens...
  function quantize (line 41) | fn quantize(
  function dequantize (line 82) | fn dequantize(tensor: QuantizedTensor<Self>) -> FloatTensor<Self> {
  function q_device (line 113) | fn q_device(tensor: &QuantizedTensor<Self>) -> Device<Self> {
  function q_to_device (line 117) | fn q_to_device(tensor: QuantizedTensor<Self>, device: &Device<Self>) -> ...
  function q_reshape (line 132) | fn q_reshape(tensor: QuantizedTensor<Self>, shape: Shape) -> QuantizedTe...
  function q_into_data (line 165) | async fn q_into_data(tensor: QuantizedTensor<Self>) -> Result<TensorData...
  function q_swap_dims (line 169) | fn q_swap_dims(
  function q_permute (line 204) | fn q_permute(tensor: QuantizedTensor<Self>, axes: &[usize]) -> Quantized...
  function q_flip (line 235) | fn q_flip(tensor: QuantizedTensor<Self>, axes: &[usize]) -> QuantizedTen...
  function q_gather (line 266) | fn q_gather(
  function q_select (line 303) | fn q_select(
  function q_slice (line 341) | fn q_slice(tensor: QuantizedTensor<Self>, slices: &[Slice]) -> Quantized...
  function q_expand (line 374) | fn q_expand(tensor: QuantizedTensor<Self>, shape: Shape) -> QuantizedTen...
  function q_matmul (line 404) | fn q_matmul(lhs: TensorPrimitive<Self>, rhs: TensorPrimitive<Self>) -> T...

FILE: crates/burn-fusion/src/ops/tensor.rs
  function float_from_data (line 22) | fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTens...
  function float_random (line 40) | fn float_random(
  function float_zeros (line 75) | fn float_zeros(shape: Shape, device: &Device<Self>, dtype: FloatDType) -...
  function float_ones (line 102) | fn float_ones(shape: Shape, device: &Device<Self>, dtype: FloatDType) ->...
  function float_full (line 129) | fn float_full(
  function float_into_data (line 175) | async fn float_into_data(tensor: FloatTensor<Self>) -> Result<TensorData...
  function float_device (line 179) | fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {
  function float_to_device (line 192) | fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> ...
  function float_into_int (line 208) | fn float_into_int(tensor: FloatTensor<Self>) -> IntTensor<Self> {
  function float_empty (line 240) | fn float_empty(shape: Shape, device: &Device<Self>, dtype: FloatDType) -...
  function float_add (line 270) | fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_add_scalar (line 289) | fn float_add_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_clamp (line 310) | fn float_clamp(tensor: FloatTensor<Self>, min: Scalar, max: Scalar) -> F...
  function float_sub (line 345) | fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_sub_scalar (line 364) | fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_mul (line 385) | fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_mul_scalar (line 404) | fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_div (line 425) | fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_div_scalar (line 444) | fn float_div_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_remainder (line 465) | fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Fl...
  function float_remainder_scalar (line 484) | fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatT...
  function float_matmul (line 505) | fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Float...
  function float_cross (line 524) | fn float_cross(
  function float_swap_dims (line 560) | fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) ...
  function float_reshape (line 591) | fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor...
  function float_gather (line 624) | fn float_gather(
  function float_scatter_add (line 661) | fn float_scatter_add(
  function float_select (line 706) | fn float_select(
  function float_select_add (line 744) | fn float_select_add(
  function float_slice (line 789) | fn float_slice(tensor: FloatTensor<Self>, slices: &[Slice]) -> FloatTens...
  function float_slice_assign (line 822) | fn float_slice_assign(
  function float_mask_where (line 861) | fn float_mask_where(
  function float_mask_fill (line 900) | fn float_mask_fill(
  function float_equal (line 939) | fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTe...
  function float_equal_elem (line 961) | fn float_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor<S...
  function float_greater (line 982) | fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Bool...
  function float_greater_elem (line 1007) | fn float_greater_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor...
  function float_greater_equal (line 1031) | fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -...
  function float_greater_equal_elem (line 1056) | fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> Bool...
  function float_lower (line 1080) | fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTe...
  function float_lower_elem (line 1102) | fn float_lower_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor<S...
  function float_lower_equal (line 1126) | fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> ...
  function float_lower_equal_elem (line 1151) | fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTe...
  function float_sum (line 1175) | fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sum_dim (line 1192) | fn float_sum_dim(tensor: FloatTensor<Self>, axis: usize) -> FloatTensor<...
  function float_prod (line 1209) | fn float_prod(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_prod_dim (line 1226) | fn float_prod_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<...
  function float_mean (line 1246) | fn float_mean(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_mean_dim (line 1263) | fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<...
  function float_cumsum (line 1283) | fn float_cumsum(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_cumprod (line 1312) | fn float_cumprod(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_cummin (line 1344) | fn float_cummin(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_cummax (line 1373) | fn float_cummax(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_exp (line 1402) | fn float_exp(lhs: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_log (line 1419) | fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_log1p (line 1436) | fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_powf_scalar_impl (line 1453) | fn float_powf_scalar_impl(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatT...
  function float_sqrt (line 1471) | fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_abs (line 1488) | fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cos (line 1505) | fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sin (line 1522) | fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_tan (line 1539) | fn float_tan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cosh (line 1556) | fn float_cosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sinh (line 1573) | fn float_sinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_tanh (line 1590) | fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_acos (line 1607) | fn float_acos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_acosh (line 1624) | fn float_acosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asin (line 1641) | fn float_asin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asinh (line 1658) | fn float_asinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan (line 1675) | fn float_atan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atanh (line 1692) | fn float_atanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan2 (line 1709) | fn float_atan2(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatT...
  function float_recip (line 1728) | fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_erf (line 1745) | fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cat (line 1762) | fn float_cat(tensors: Vec<FloatTensor<Self>>, dim: usize) -> FloatTensor...
  function float_argmax (line 1799) | fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {
  function float_repeat_dim (line 1822) | fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize)...
  function float_argmin (line 1855) | fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {
  function float_max (line 1877) | fn float_max(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_max_dim (line 1894) | fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_max_dim_with_indices (line 1911) | fn float_max_dim_with_indices(
  function float_min (line 1952) | fn float_min(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_min_dim (line 1969) | fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_min_dim_with_indices (line 1986) | fn float_min_dim_with_indices(
  function float_max_abs (line 2026) | fn float_max_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_max_abs_dim (line 2043) | fn float_max_abs_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTens...
  function float_powf (line 2064) | fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTe...
  function float_permute (line 2083) | fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTens...
  function float_expand (line 2114) | fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<...
  function float_flip (line 2144) | fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<...
  function float_round (line 2175) | fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_floor (line 2192) | fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_ceil (line 2209) | fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_trunc (line 2226) | fn float_trunc(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cast (line 2243) | fn float_cast(tensor: FloatTensor<Self>, dtype: burn_backend::FloatDType...
  function float_unfold (line 2275) | fn float_unfold(
  function float_is_nan (line 2312) | fn float_is_nan(tensor: FloatTensor<Self>) -> BoolTensor<Self> {
  function float_is_inf (line 2343) | fn float_is_inf(tensor: FloatTensor<Self>) -> BoolTensor<Self> {
  function float_grid_sample_2d (line 2374) | fn float_grid_sample_2d(

FILE: crates/burn-fusion/src/ops/transaction.rs
  function tr_execute (line 9) | async fn tr_execute(

FILE: crates/burn-fusion/src/search/block.rs
  type Block (line 10) | pub struct Block<O> {
  type RegistrationResult (line 22) | pub enum RegistrationResult {
  type BlockOptimization (line 33) | pub struct BlockOptimization<O> {
  function new (line 42) | pub fn new(builders: &[Box<dyn OperationFuser<O>>]) -> Self {
  function sort (line 54) | pub fn sort(blocks: &mut [Self]) {
  function optimize (line 59) | pub fn optimize(mut self) -> BlockOptimization<O> {
  function contains_tensors (line 84) | pub fn contains_tensors(&self, tensors: &[&TensorIr]) -> bool {
  function merge (line 99) | pub fn merge(&mut self, other: &Block<O>) -> bool {
  function register (line 117) | pub fn register(
  function still_optimizing (line 145) | pub fn still_optimizing(&self) -> bool {
  function register_op (line 157) | fn register_op(&mut self, operation: &OperationIr, pos: usize) {
  function map_ordering (line 180) | pub fn map_ordering(&mut self, mapping: &[usize]) {
  function map_ordering (line 190) | pub fn map_ordering(&mut self, mapping: &[usize]) {
  function find_best_optimization_index (line 218) | fn find_best_optimization_index<O>(
  method eq (line 238) | fn eq(&self, other: &Self) -> bool {
  function fmt (line 251) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method clone (line 262) | fn clone(&self) -> Self {

FILE: crates/burn-fusion/src/search/merging.rs
  type MergeBlocksResult (line 6) | pub enum MergeBlocksResult<O> {
  function merge_blocks (line 35) | pub fn merge_blocks<O: NumOperations>(blocks: &[&Block<O>], sorted: bool...
  type MergeBlockStep1 (line 83) | struct MergeBlockStep1<O> {
  method default (line 90) | fn default() -> Self {
  function merge_blocks_step1 (line 99) | fn merge_blocks_step1<O: NumOperations>(blocks: &[&Block<O>]) -> MergeBl...
  function merge_blocks_step2 (line 131) | fn merge_blocks_step2<O: NumOperations>(mut step1: MergeBlockStep1<O>) -...
  function merge_accumulator (line 226) | fn merge_accumulator<O: NumOperations>(
  function merge_two (line 261) | fn merge_two<O: NumOperations>(a: &Block<O>, b: &Block<O>) -> Option<Blo...
  function test_merge_blocks_no_block (line 286) | fn test_merge_blocks_no_block() {
  function test_merge_blocks_single (line 293) | fn test_merge_blocks_single() {
  function test_merge_blocks_two_blocks (line 302) | fn test_merge_blocks_two_blocks() {
  function test_merge_blocks_three_blocks (line 323) | fn test_merge_blocks_three_blocks() {
  function test_merge_blocks_three_blocks_partial (line 343) | fn test_merge_blocks_three_blocks_partial() {
  function test_merge_blocks_four_blocks_partial_with_failure (line 370) | fn test_merge_blocks_four_blocks_partial_with_failure() {
  function test_merge_blocks_five_blocks_partial_with_failure (line 401) | fn test_merge_blocks_five_blocks_partial_with_failure() {
  function builders (line 435) | fn builders() -> Vec<Box<dyn OperationFuser<TestOptimization>>> {

FILE: crates/burn-fusion/src/search/optimization/blocks.rs
  type BlocksOptimizer (line 22) | pub struct BlocksOptimizer<O> {
  type BlocksOptimizerResult (line 29) | pub enum BlocksOptimizerResult<O> {
  type BlockOptimizationStep (line 40) | enum BlockOptimizationStep<O> {
  function new (line 57) | pub fn new(blocks: Vec<Block<O>>) -> Self {
  function optimize (line 72) | pub fn optimize(mut self) -> BlocksOptimizerResult<O> {
  function optimize_block (line 119) | fn optimize_block(
  function optimize_holes (line 148) | fn optimize_holes(
  function update_check (line 180) | fn update_check(&mut self, pos: usize) {
  function find_holes (line 192) | fn find_holes(&mut self, last: usize) -> Vec<usize> {
  function merging_pass (line 207) | fn merging_pass(mut self) -> Self {

FILE: crates/burn-fusion/src/search/optimization/stream.rs
  type StreamOptimizer (line 14) | pub struct StreamOptimizer<O> {
  function new (line 24) | pub fn new(builders: Vec<Box<dyn OperationFuser<O>>>) -> Self {
  function register (line 39) | pub fn register(&mut self, operation: &OperationIr) {
  function optimize (line 83) | pub fn optimize(&self, operations: &[OperationIr]) -> BlockOptimization<...
  function reset (line 123) | pub fn reset(&mut self) {
  function still_optimizing (line 131) | pub fn still_optimizing(&self) -> bool {
  function register_max_block (line 150) | fn register_max_block(&mut self, operation: &OperationIr, max_blocks: us...
  function register_inner (line 183) | fn register_inner(&mut self, operation: &OperationIr, force: bool) -> us...
  function new_empty_search (line 196) | fn new_empty_search(&self) -> Self {
  function merge_blocks (line 209) | fn merge_blocks(&mut self, operation: &OperationIr, all: bool) -> MergeB...
  function on_new_block (line 265) | fn on_new_block(&mut self, operation: &OperationIr) {
  type MergeBlockStep (line 272) | enum MergeBlockStep {

FILE: crates/burn-fusion/src/server.rs
  type FusionServer (line 10) | pub struct FusionServer<R: FusionRuntime> {
  function new (line 19) | pub fn new(device: R::FusionDevice) -> Self {
  function register (line 26) | pub fn register(
  function drain_stream (line 36) | pub fn drain_stream(&mut self, id: StreamId) {
  function read_float (line 40) | pub fn read_float<B>(
  function read_int (line 56) | pub fn read_int<B>(
  function read_bool (line 72) | pub fn read_bool<B>(
  function read_quantized (line 88) | pub fn read_quantized<B>(
  function change_server_float (line 104) | pub fn change_server_float<B>(
  function resolve_server_float (line 124) | pub fn resolve_server_float<B>(&mut self, tensor: &TensorIr) -> B::Float...
  function resolve_server_int (line 131) | pub fn resolve_server_int<B>(&mut self, tensor: &TensorIr) -> B::IntTens...
  function resolve_server_bool (line 138) | pub fn resolve_server_bool<B>(&mut self, tensor: &TensorIr) -> B::BoolTe...
  function change_server_int (line 145) | pub fn change_server_int<B>(
  function change_server_bool (line 164) | pub fn change_server_bool<B>(
  function change_server_quantized (line 183) | pub fn change_server_quantized<B>(

FILE: crates/burn-fusion/src/stream/context.rs
  type Context (line 13) | pub struct Context<'a, H> {
  type ScalarId (line 26) | pub struct ScalarId {
  type OperationConverter (line 31) | pub(crate) struct OperationConverter {
    method context (line 112) | pub(crate) fn context<'a, H>(
    method clear (line 124) | pub(crate) fn clear(&mut self) {
  method default (line 40) | fn default() -> Self {
  type ContextOwned (line 58) | pub struct ContextOwned<H> {
  function as_context (line 67) | pub fn as_context(&mut self) -> Context<'_, H> {
  function fork (line 77) | pub fn fork(&self) -> ContextOwned<H> {
  function fork (line 89) | pub fn fork(&self) -> ContextOwned<H> {
  type RelativeOps (line 99) | pub(crate) trait RelativeOps {
    method to_relative (line 108) | fn to_relative(&self, converter: &mut OperationConverter) -> Self;
    method to_relative (line 140) | fn to_relative(&self, converter: &mut OperationConverter) -> Self {
    method to_relative (line 165) | fn to_relative(&self, converter: &mut OperationConverter) -> Self {
    method to_relative (line 502) | fn to_relative(&self, converter: &mut OperationConverter) -> Self {
    method to_relative (line 659) | fn to_relative(&self, converter: &mut OperationConverter) -> Self {
    method to_relative (line 688) | fn to_relative(&self, converter: &mut OperationConverter) -> Self {
    method to_relative (line 770) | fn to_relative(&self, converter: &mut OperationConverter) -> CustomOpIr {
    method to_relative (line 790) | fn to_relative(&self, converter: &mut OperationConverter) -> Self {
    method to_relative (line 1018) | fn to_relative(&self, converter: &mut OperationConverter) -> Self {
    method to_relative (line 1141) | fn to_relative(&self, converter: &mut OperationConverter) -> Self {
    method to_relative (line 1149) | fn to_relative(&self, converter: &mut OperationConverter) -> Self {
    method to_relative (line 1157) | fn to_relative(&self, converter: &mut OperationConverter) -> Self {
    method to_relative (line 1197) | fn to_relative(&self, converter: &mut OperationConverter) -> Self {
    method to_relative (line 1210) | fn to_relative(&self, converter: &mut OperationConverter) -> Self {
  function tensor_description_to_relative (line 1231) | fn tensor_description_to_relative() {
  function scalar_ir_to_relative (line 1269) | fn scalar_ir_to_relative() {

FILE: crates/burn-fusion/src/stream/execution/base.rs
  type ExecutionMode (line 7) | pub(crate) enum ExecutionMode {
  type Operation (line 13) | pub trait Operation<R: FusionRuntime>: Send + Sync + core::fmt::Debug {
    method execute (line 15) | fn execute(&self, handles: &mut HandleContainer<R::FusionHandle>);

FILE: crates/burn-fusion/src/stream/execution/explorer.rs
  type Explorer (line 10) | pub struct Explorer<O> {
  type ExplorationAction (line 18) | pub enum ExplorationAction<O> {
  function new (line 27) | pub(crate) fn new(optimizations: Vec<Box<dyn OperationFuser<O>>>) -> Self {
  function on_new_operation (line 37) | pub(crate) fn on_new_operation(&mut self) {
  function is_up_to_date (line 42) | pub(crate) fn is_up_to_date(&self) -> bool {
  function explore (line 47) | pub(crate) fn explore(
  function reset (line 67) | pub(crate) fn reset(&mut self, operations: &[OperationIr]) {
  function update (line 75) | fn update(&mut self, operations: &[OperationIr]) {

FILE: crates/burn-fusion/src/stream/execution/ordering.rs
  type OrderedExecution (line 10) | pub struct OrderedExecution<R: FusionRuntime> {
  function operation_within_optimization (line 21) | pub fn operation_within_optimization(&self, index: usize) -> Arc<dyn Ope...
  function new (line 31) | pub(crate) fn new(operations: Vec<Arc<dyn Operation<R>>>) -> Self {
  function finish (line 39) | pub(crate) fn finish(mut self) -> (Vec<Arc<dyn Operation<R>>>, usize) {
  function execute_optimization (line 44) | pub(crate) fn execute_optimization(
  function execute_operations (line 59) | pub(crate) fn execute_operations(

FILE: crates/burn-fusion/src/stream/execution/policy.rs
  type Policy (line 22) | pub(crate) struct Policy<O> {
  type AvailableItem (line 37) | struct AvailableItem {
  type Action (line 45) | pub enum Action {
  function new (line 61) | pub(crate) fn new() -> Self {
  function action (line 72) | pub fn action(
  function update (line 95) | pub fn update(&mut self, store: &ExecutionPlanStore<O>, operation: &Oper...
  function reset (line 114) | pub fn reset(&mut self) {
  function check_candidates (line 124) | fn check_candidates(&mut self, store: &ExecutionPlanStore<O>) {
  function check_availables (line 164) | fn check_availables(&mut self) {
  function update_candidates (line 192) | fn update_candidates(&mut self, store: &ExecutionPlanStore<O>, operation...
  function update_availables (line 200) | fn update_availables(&mut self, store: &ExecutionPlanStore<O>, operation...
  function action_lazy (line 220) | fn action_lazy(&self, operations: &[OperationIr]) -> Action {
  function action_sync (line 245) | fn action_sync(&self, operations: &[OperationIr], store: &ExecutionPlanS...
  function given_no_optimization_should_explore (line 277) | fn given_no_optimization_should_explore() {
  function given_existing_optimizations_when_sync_should_execute_one_when_available (line 291) | fn given_existing_optimizations_when_sync_should_execute_one_when_availa...
  function given_existing_plan_when_found_trigger_should_execute_plan (line 319) | fn given_existing_plan_when_found_trigger_should_execute_plan() {
  function should_support_multiple_triggers (line 348) | fn should_support_multiple_triggers() {
  function should_select_right_optimization (line 399) | fn should_select_right_optimization() {
  function should_invalidate_wrong_optimizations (line 460) | fn should_invalidate_wrong_optimizations() {
  type TestStream (line 495) | struct TestStream {
    method new (line 507) | pub fn new(num_ops: usize) -> Self {
    method assert_updates (line 517) | pub fn assert_updates(
    method new_ops (line 539) | pub fn new_ops(&mut self, out_id: u64) {
    method new_empty_node (line 554) | fn new_empty_node(&mut self, id: u64) {
    method unary_description (line 563) | fn unary_description(&self) -> UnaryOpIr {
  type AssertUpdatesOptions (line 501) | enum AssertUpdatesOptions {

FILE: crates/burn-fusion/src/stream/execution/processor.rs
  type Processor (line 10) | pub(crate) struct Processor<O> {
  type StreamSegment (line 16) | pub(crate) trait StreamSegment<O> {
    method operations (line 18) | fn operations(&self) -> &[OperationIr];
    method execute (line 20) | fn execute(&mut self, id: ExecutionPlanId, store: &mut ExecutionPlanSt...
  function new (line 25) | pub fn new(optimizations: Vec<Box<dyn OperationFuser<O>>>) -> Self {
  function process (line 33) | pub fn process<Segment>(
  function on_new_operation (line 79) | fn on_new_operation<Segment>(&mut self, segment: &Segment, store: &mut E...
  function explore (line 93) | fn explore<Item: StreamSegment<O>>(
  function reset (line 119) | fn reset(&mut self, store: &mut ExecutionPlanStore<O>, operations: &[Ope...
  function on_exploration_completed (line 131) | fn on_exploration_completed(

FILE: crates/burn-fusion/src/stream/execution/tests.rs
  type TestStream (line 28) | pub struct TestStream {
    method new (line 435) | fn new(optimizations: Vec<Box<dyn OperationFuser<TestOptimization>>>) ...
    method add (line 445) | fn add(&mut self, operation: OperationIr) {
    method sync (line 455) | fn sync(&mut self) {
    method assert_plan (line 464) | fn assert_plan(&self, id: ExecutionPlanId, expected: ExecutionPlan<Tes...
    method assert_last_executed (line 471) | fn assert_last_executed(&self, id: ExecutionPlanId) {
    method assert_number_of_executions (line 479) | fn assert_number_of_executions(&self, number: usize) {
    method assert_number_of_operations (line 484) | fn assert_number_of_operations(&self, number: usize) {
  type TestOptimizationBuilder (line 40) | pub struct TestOptimizationBuilder {
    method new (line 491) | pub fn new(builder_id: usize, operations: Vec<OperationIr>) -> Self {
    method fuse (line 502) | fn fuse(&mut self, operation: &OperationIr) {
    method finish (line 507) | fn finish(&mut self) -> TestOptimization {
    method reset (line 512) | fn reset(&mut self) {
    method status (line 517) | fn status(&self) -> FuserStatus {
    method properties (line 533) | fn properties(&self) -> FuserProperties {
    method len (line 561) | fn len(&self) -> usize {
    method clone_dyn (line 564) | fn clone_dyn(&self) -> Box<dyn OperationFuser<TestOptimization>> {
  type TestOptimization (line 48) | pub struct TestOptimization {
  method len (line 54) | fn len(&self) -> usize {
  type TestSegment (line 61) | pub struct TestSegment<'i> {
  function operations (line 68) | pub fn operations(size: usize) -> Self {
  function optimization (line 77) | pub fn optimization(opt: TestOptimization) -> Self {
  function should_support_complex_stream (line 88) | fn should_support_complex_stream() {
  function should_reuse_basic_operations (line 202) | fn should_reuse_basic_operations() {
  function should_support_overlapping_optimizations (line 266) | fn should_support_overlapping_optimizations() {
  function operations (line 571) | fn operations(&self) -> &[OperationIr] {
  function execute (line 576) | fn execute(&mut self, id: ExecutionPlanId, store: &mut ExecutionPlanStor...
  function execute_strategy (line 586) | fn execute_strategy(&mut self, strategy: &ExecutionStrategy<TestOptimiza...
  function operation_1 (line 604) | pub fn operation_1() -> OperationIr {
  function operation_2 (line 631) | pub fn operation_2() -> OperationIr {
  function operation_3 (line 653) | pub fn operation_3() -> OperationIr {

FILE: crates/burn-fusion/src/stream/execution/validator.rs
  type OperationsValidator (line 11) | pub(crate) struct OperationsValidator<ID> {
  type ValidatorState (line 20) | pub(crate) enum ValidatorState {
  type OperationsStore (line 30) | pub(crate) trait OperationsStore {
    method get (line 35) | fn get(&self, id: Self::Id) -> &[OperationIr];
    type Id (line 112) | type Id = TriggerId;
    method get (line 114) | fn get(&self, id: Self::Id) -> &[OperationIr] {
    type Id (line 131) | type Id = ExecutionPlanId;
    method get (line 133) | fn get(&self, id: Self::Id) -> &[OperationIr] {
  function new (line 40) | pub(crate) fn new(id: ID) -> Self {
  function update (line 48) | pub(crate) fn update<S>(&mut self, added: &OperationIr, added_position: ...
  type TriggerOperationsStore (line 82) | pub(crate) struct TriggerOperationsStore<'a, O> {
  type TriggerValidator (line 89) | pub(crate) enum TriggerValidator {
  type TriggerProgress (line 100) | pub(crate) enum TriggerProgress {
  type TriggerId (line 109) | pub(crate) type TriggerId = usize;
  type ExecutionPlanOperationsStore (line 126) | pub(crate) struct ExecutionPlanOperationsStore<'a, O> {

FILE: crates/burn-fusion/src/stream/memory_checks.rs
  type MemoryChecks (line 22) | pub(crate) struct MemoryChecks {
    method check (line 157) | pub(crate) fn check<R: FusionRuntime>(
    method spawn_new (line 185) | fn spawn_new() -> Self {
    method final_check (line 242) | fn final_check(analyses: StreamAnalyses) -> MemoryReport {
  type Message (line 29) | enum Message {
  type MemoryReport (line 34) | enum MemoryReport {
  type StreamAnalyses (line 42) | struct StreamAnalyses {
  method fmt (line 48) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Analysis (line 70) | struct Analysis {
  function check_memory_leaks (line 93) | pub fn check_memory_leaks() {
  function fetch_memory_report (line 118) | fn fetch_memory_report() -> MemoryReport {
  method default (line 141) | fn default() -> Self {

FILE: crates/burn-fusion/src/stream/multi.rs
  type MultiStream (line 19) | pub struct MultiStream<R: FusionRuntime> {
  type DropAction (line 29) | enum DropAction {
  function new (line 36) | pub(crate) fn new(device: R::FusionDevice) -> Self {
  function register (line 48) | pub(crate) fn register(
  function handle_drop_op (line 112) | fn handle_drop_op(&mut self, id: StreamId, tensor_ir: &mut TensorIr) -> ...
  function enqueue_operation (line 133) | fn enqueue_operation(
  function mark_read (line 170) | pub fn mark_read(
  function drain (line 196) | pub fn drain(&mut self, handles: &mut HandleContainer<R::FusionHandle>, ...
  function resolve_streams (line 221) | fn resolve_streams(
  function resolve_stream (line 240) | fn resolve_stream(
  function analyse_shared_tensors (line 256) | fn analyse_shared_tensors(
  function merge_streams_timelines (line 290) | fn merge_streams_timelines(
  function register_shared_tensors_drop (line 331) | fn register_shared_tensors_drop(
  function drop_shared_tensors (line 354) | fn drop_shared_tensors(
  function clear_shared_tensors (line 379) | fn clear_shared_tensors(&mut self, tensors: &[TensorId], current: Stream...
  type Stream (line 397) | pub(crate) struct Stream<R: FusionRuntime> {
  type Segment (line 404) | struct Segment<'a, R: FusionRuntime> {
  function operations (line 410) | fn operations(&self) -> &[OperationIr] {
  function execute (line 414) | fn execute(&mut self, id: ExecutionPlanId, store: &mut ExecutionPlanStor...
  function new (line 420) | fn new(device: R::FusionDevice) -> Self {
  type OperationStreams (line 431) | pub struct OperationStreams {
    method tensor (line 450) | pub fn tensor<R: FusionRuntime>(&mut self, tensor: &crate::FusionTenso...
    method get (line 454) | pub(crate) fn get(&self, id: TensorId) -> Option<StreamId> {
    method with_inputs (line 461) | pub fn with_inputs<'a, R: FusionRuntime + 'a, I>(tensors: I) -> Self
  method default (line 437) | fn default() -> Self {
  type MultiSharedTensorAnalysis (line 474) | struct MultiSharedTensorAnalysis {

FILE: crates/burn-fusion/src/stream/queue/base.rs
  type OperationQueue (line 11) | pub struct OperationQueue<R: FusionRuntime> {
  method default (line 27) | fn default() -> Self {
  function new (line 34) | pub fn new() -> Self {
  function add (line 49) | pub fn add(
  function stream_id_from_different_threads (line 75) | fn stream_id_from_different_threads() {

FILE: crates/burn-fusion/src/stream/queue/execution.rs
  function execute (line 18) | pub(crate) fn execute(
  function execute_block_optimization (line 28) | fn execute_block_optimization(
  function drain_queue (line 44) | fn drain_queue(&mut self, num_drained: usize, handles: &mut HandleContai...
  function reset_relative (line 60) | fn reset_relative(&mut self) {
  type QueueExecution (line 73) | enum QueueExecution<'a, R: FusionRuntime> {
  function run (line 86) | fn run(
  function execute_strategy (line 122) | fn execute_strategy(mut self, strategy: &mut ExecutionStrategy<R::Optimi...

FILE: crates/burn-fusion/src/stream/shared_tensors.rs
  type SharedTensors (line 10) | pub struct SharedTensors {
    method on_drop (line 61) | pub fn on_drop(
    method on_executed_ops (line 97) | pub fn on_executed_ops<R: FusionRuntime>(
    method clear_tensors (line 122) | pub fn clear_tensors(&mut self, tensors: Vec<TensorId>) -> Vec<TensorI...
    method streams_of (line 135) | pub fn streams_of(&mut self, tensor: &TensorId) -> Vec<StreamId> {
    method analyse (line 148) | pub fn analyse<R: FusionRuntime>(
    method tag_manual_drop (line 197) | pub fn tag_manual_drop(&mut self, dropped: Vec<TensorIr>) {
    method register_manual_drop (line 203) | fn register_manual_drop(&mut self, mut tensors: Vec<TensorIr>) -> Vec<...
    method fmt (line 298) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type SharedTensor (line 17) | struct SharedTensor {
    method register_new_stream (line 241) | fn register_new_stream<R: FusionRuntime>(
    method update (line 271) | fn update<R: FusionRuntime>(&mut self, id: StreamId, stream: &Stream<R...
    method drop (line 292) | fn drop(&mut self, id: StreamId) {
  type SharedTensorState (line 22) | struct SharedTensorState {
  type SharedTensorDropAction (line 29) | pub enum SharedTensorDropAction {
  type SharedTensorAnalysis (line 39) | pub enum SharedTensorAnalysis {
  type SharedTensorUpdate (line 225) | pub enum SharedTensorUpdate {

FILE: crates/burn-fusion/src/stream/store/base.rs
  type ExecutionPlanStore (line 11) | pub(crate) struct ExecutionPlanStore<O> {
  type ExecutionStrategy (line 18) | pub(crate) enum ExecutionStrategy<O> {
  type ExecutionTrigger (line 29) | pub(crate) enum ExecutionTrigger {
  type ExecutionPlanId (line 36) | pub(crate) type ExecutionPlanId = usize;
  type ExecutionPlan (line 40) | pub(crate) struct ExecutionPlan<O> {
  function new (line 50) | pub fn new() -> Self {
  function find (line 57) | pub fn find(&self, query: SearchQuery<'_>) -> Vec<ExecutionPlanId> {
  function add (line 61) | pub fn add(&mut self, exploration: ExecutionPlan<O>) -> ExecutionPlanId {
  function get_mut_unchecked (line 78) | pub fn get_mut_unchecked(&mut self, id: ExecutionPlanId) -> &mut Executi...
  function get_unchecked (line 82) | pub fn get_unchecked(&self, id: ExecutionPlanId) -> &ExecutionPlan<O> {
  function add_trigger (line 87) | pub fn add_trigger(&mut self, id: ExecutionPlanId, trigger: ExecutionTri...

FILE: crates/burn-fusion/src/stream/store/index.rs
  type ExecutionPlanIndex (line 11) | pub struct ExecutionPlanIndex {
    method find (line 41) | pub fn find(&self, query: SearchQuery<'_>) -> Vec<ExecutionPlanId> {
    method insert (line 48) | pub fn insert(&mut self, query: InsertQuery<'_>) {
    method find_starting_with (line 59) | fn find_starting_with(&self, operation: &OperationIr) -> Vec<Execution...
    method insert_new_operation (line 82) | fn insert_new_operation(&mut self, ops: &OperationIr, new_id: Executio...
    method operation_key (line 114) | fn operation_key(&self, ops: &OperationIr) -> u64 {
  type SearchQuery (line 28) | pub enum SearchQuery<'a> {
  type InsertQuery (line 32) | pub enum InsertQuery<'a> {
  function should_find_optimization_id_based_on_tensor_ops (line 131) | fn should_find_optimization_id_based_on_tensor_ops() {
  function should_support_multiple_optimization_ids_with_same_starting_ops (line 147) | fn should_support_multiple_optimization_ids_with_same_starting_ops() {
  function should_only_find_optimization_with_correct_starting_ops (line 169) | fn should_only_find_optimization_with_correct_starting_ops() {
  function should_handle_hash_collisions (line 191) | fn should_handle_hash_collisions() {
  function ops_1 (line 221) | fn ops_1() -> OperationIr {
  function ops_2 (line 247) | fn ops_2() -> OperationIr {
  function ops_3 (line 268) | fn ops_3() -> OperationIr {

FILE: crates/burn-fusion/src/tensor.rs
  type FusionTensor (line 16) | pub struct FusionTensor<R: FusionRuntime> {
  method clone (line 31) | fn clone(&self) -> Self {
  function fmt (line 46) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method dtype (line 60) | fn dtype(&self) -> DType {
  method shape (line 64) | fn shape(&self) -> Shape {
  method rank (line 68) | fn rank(&self) -> usize {
  function new (line 74) | pub(crate) fn new(
  function status (line 91) | fn status(&self, count: u32) -> TensorStatus {
  function to_ir_out (line 100) | pub fn to_ir_out(&self) -> TensorIr {
  function into_ir (line 110) | pub fn into_ir(mut self) -> TensorIr {
  function into_data (line 133) | pub(crate) async fn into_data<B>(self) -> Result<TensorData, ExecutionEr...
  function q_into_data (line 143) | pub(crate) async fn q_into_data<B>(self) -> Result<TensorData, Execution...
  function int_into_data (line 157) | pub(crate) async fn int_into_data<B>(self) -> Result<TensorData, Executi...
  function bool_into_data (line 167) | pub(crate) async fn bool_into_data<B>(self) -> Result<TensorData, Execut...
  type DropOp (line 179) | pub(crate) struct DropOp {
    method execute (line 184) | fn execute(&self, handles: &mut burn_ir::HandleContainer<RO::FusionHan...
  method drop (line 190) | fn drop(&mut self) {
  method scheme (line 222) | fn scheme(&self) -> &QuantScheme {

FILE: crates/burn-ir/src/backend.rs
  type TensorHandle (line 8) | pub struct TensorHandle<H: Clone> {
  type BackendIr (line 17) | pub trait BackendIr: Backend {
    method float_tensor (line 22) | fn float_tensor(handle: TensorHandle<Self::Handle>) -> FloatTensor<Self>;
    method int_tensor (line 24) | fn int_tensor(handle: TensorHandle<Self::Handle>) -> IntTensor<Self>;
    method bool_tensor (line 26) | fn bool_tensor(handle: TensorHandle<Self::Handle>) -> BoolTensor<Self>;
    method quantized_tensor (line 28) | fn quantized_tensor(handle: TensorHandle<Self::Handle>) -> QuantizedTe...
    method float_tensor_handle (line 31) | fn float_tensor_handle(tensor: FloatTensor<Self>) -> Self::Handle;
    method int_tensor_handle (line 33) | fn int_tensor_handle(tensor: IntTensor<Self>) -> Self::Handle;
    method bool_tensor_handle (line 35) | fn bool_tensor_handle(tensor: BoolTensor<Self>) -> Self::Handle;
    method quantized_tensor_handle (line 37) | fn quantized_tensor_handle(tensor: QuantizedTensor<Self>) -> Self::Han...
  type HandleKind (line 42) | pub enum HandleKind<B: Backend> {
  function name (line 55) | pub fn name(&self) -> &str {

FILE: crates/burn-ir/src/builder.rs
  method create (line 22) | pub fn create(shape: Shape, dtype: DType, new_id: impl FnOnce() -> Tenso...
  method create (line 30) | pub fn create(shape: Shape, dtype: DType, new_id: impl FnOnce() -> Tenso...
  method create (line 38) | pub fn create(
  method create (line 51) | pub fn create(
  method create (line 65) | pub fn create(input: TensorIr, dtype: DType, new_id: impl FnOnce() -> Te...
  method expand (line 72) | pub fn expand(input: TensorIr, shape: Shape, new_id: impl FnOnce() -> Te...
  method reshape (line 77) | pub fn reshape(input: TensorIr, shape: Shape, new_id: impl FnOnce() -> T...
  method create (line 82) | fn create(input: TensorIr, shape: Shape, new_id: impl FnOnce() -> Tensor...
  method from (line 91) | fn from(value: MatmulOpIr) -> Self {
  method from (line 101) | fn from(value: ReduceOpIr) -> Self {
  type IrError (line 111) | pub enum IrError {
  function dtype_compat (line 115) | fn dtype_compat(lhs: &DType, rhs: &DType) -> bool {
  function output_check (line 127) | fn output_check<'a, I>(inputs: I, compat: impl Fn(&DType, &DType) -> boo...
  function output_dtype (line 141) | fn output_dtype<'a, I: IntoIterator<Item = &'a DType>>(inputs: I) -> Res...
  function output_dtype_mixed (line 145) | fn output_dtype_mixed<'a, I: IntoIterator<Item = &'a DType>>(inputs: I) ...
  method create (line 960) | pub fn create(input: TensorIr, dtype: DType, new_id: impl FnOnce() -> Te...
  method create (line 970) | pub fn create(
  method create (line 992) | pub fn create(
  method create (line 1043) | pub fn create(
  method create (line 1080) | pub fn create(

FILE: crates/burn-ir/src/handle.rs
  type HandleContainer (line 8) | pub struct HandleContainer<H> {
  function fork (line 15) | pub fn fork(&self) -> Self {
  function fmt (line 30) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type Handle (line 40) | pub enum Handle<H> {
  function new (line 49) | pub fn new() -> Self {
  function register_handle (line 57) | pub fn register_handle(&mut self, id: TensorId, handle: H) {
  function has_handle (line 62) | pub fn has_handle(&mut self, id: &TensorId) -> bool {
  function get_handle_ref (line 67) | pub fn get_handle_ref(&self, id: &TensorId) -> Option<&H> {
  function get_handle (line 84) | pub fn get_handle(&mut self, id: &TensorId, status: &TensorStatus) -> H {
  function get_tensor_handle (line 106) | pub fn get_tensor_handle(&mut self, tensor: &TensorIr) -> TensorHandle<H> {
  function get_float_tensor (line 115) | pub fn get_float_tensor<B>(&mut self, tensor: &TensorIr) -> B::FloatTens...
  function get_int_tensor (line 124) | pub fn get_int_tensor<B>(&mut self, tensor: &TensorIr) -> B::IntTensorPr...
  function get_bool_tensor (line 133) | pub fn get_bool_tensor<B>(&mut self, tensor: &TensorIr) -> B::BoolTensor...
  function get_quantized_tensor (line 142) | pub fn get_quantized_tensor<B>(&mut self, tensor: &TensorIr) -> B::Quant...
  function register_float_tensor (line 150) | pub fn register_float_tensor<B>(&mut self, id: &TensorId, tensor: B::Flo...
  function register_quantized_tensor (line 159) | pub fn register_quantized_tensor<B>(
  function register_int_tensor (line 171) | pub fn register_int_tensor<B>(&mut self, id: &TensorId, tensor: B::IntTe...
  function register_bool_tensor (line 180) | pub fn register_bool_tensor<B>(&mut self, id: &TensorId, tensor: B::Bool...
  function remove_handle (line 189) | pub fn remove_handle(&mut self, id: TensorId) -> Option<Handle<H>> {
  function free (line 194) | pub fn free(&mut self, tensor: &TensorIr) {
  function num_handles (line 205) | pub fn num_handles(&self) -> usize {

FILE: crates/burn-ir/src/operation.rs
  type CustomOpIr (line 23) | pub struct CustomOpIr {
    method new (line 34) | pub fn new(id: &'static str, inputs: &[TensorIr], outputs: &[TensorIr]...
    method as_fixed (line 43) | pub fn as_fixed<const N_IN: usize, const N_OUT: usize>(
    method inputs (line 56) | fn inputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method outputs (line 60) | fn outputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
  type OperationIr (line 68) | pub enum OperationIr {
    method inputs (line 1740) | pub fn inputs(&self) -> impl Iterator<Item = &TensorIr> {
    method outputs (line 1758) | pub fn outputs(&self) -> impl Iterator<Item = &TensorIr> {
    method nodes (line 1776) | pub fn nodes(&self) -> Vec<&TensorIr> {
    method mark_read_only (line 1784) | pub fn mark_read_only(&mut self, nodes: &[TensorId]) -> Vec<TensorIr> {
  type FloatOperationIr (line 97) | pub enum FloatOperationIr {
    method inputs (line 2206) | fn inputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method outputs (line 2248) | fn outputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method mark_read_only (line 2287) | fn mark_read_only(&mut self, nodes: &[TensorId]) -> Vec<TensorIr> {
  type ModuleOperationIr (line 170) | pub enum ModuleOperationIr {
    method inputs (line 2524) | fn inputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method outputs (line 2680) | fn outputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method mark_read_only (line 2763) | fn mark_read_only(&mut self, nodes: &[TensorId]) -> Vec<TensorIr> {
  type BaseOperationIr (line 259) | pub enum BaseOperationIr {
    method inputs (line 1815) | fn inputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method outputs (line 1848) | fn outputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method mark_read_only (line 1875) | fn mark_read_only(&mut self, nodes: &[TensorId]) -> Vec<TensorIr> {
  type NumericOperationIr (line 394) | pub enum NumericOperationIr {
    method inputs (line 1961) | fn inputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method outputs (line 2009) | fn outputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method mark_read_only (line 2060) | fn mark_read_only(&mut self, nodes: &[TensorId]) -> Vec<TensorIr> {
  type IntOperationIr (line 613) | pub enum IntOperationIr {
    method inputs (line 2386) | fn inputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method outputs (line 2404) | fn outputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method mark_read_only (line 2422) | fn mark_read_only(&mut self, nodes: &[TensorId]) -> Vec<TensorIr> {
  type BoolOperationIr (line 666) | pub enum BoolOperationIr {
    method inputs (line 2478) | fn inputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method outputs (line 2487) | fn outputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method mark_read_only (line 2496) | fn mark_read_only(&mut self, nodes: &[TensorId]) -> Vec<TensorIr> {
  type SwapDimsOpIr (line 681) | pub struct SwapDimsOpIr {
  type PermuteOpIr (line 694) | pub struct PermuteOpIr {
  type ShapeOpIr (line 705) | pub struct ShapeOpIr {
  type UnfoldOpIr (line 714) | pub struct UnfoldOpIr {
  type FlipOpIr (line 730) | pub struct FlipOpIr {
  type RandomOpIr (line 741) | pub struct RandomOpIr {
    method hash (line 2992) | fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
  type CreationOpIr (line 749) | pub struct CreationOpIr {
  type FullOpIr (line 756) | pub struct FullOpIr {
  type InitOperationIr (line 767) | pub struct InitOperationIr {
    method inputs (line 2974) | fn inputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
    method outputs (line 2977) | fn outputs(&self) -> Box<dyn Iterator<Item = &TensorIr> + '_> {
  type BinaryOpIr (line 774) | pub struct BinaryOpIr {
  type MatmulOpIr (line 782) | pub struct MatmulOpIr {
  type CrossOpIr (line 790) | pub struct CrossOpIr {
  type UnaryOpIr (line 799) | pub struct UnaryOpIr {
  type ScalarOpIr (line 806) | pub struct ScalarOpIr {
  type ReduceOpIr (line 816) | pub struct ReduceOpIr {
  type ReduceDimOpIr (line 823) | pub struct ReduceDimOpIr {
  type CastOpIr (line 831) | pub struct CastOpIr {
  type DimOpIr (line 840) | pub struct DimOpIr {
  type GatherOpIr (line 848) | pub struct GatherOpIr {
  type ScatterOpIr (line 857) | pub struct ScatterOpIr {
  type SelectOpIr (line 868) | pub struct SelectOpIr {
  type SelectAssignOpIr (line 877) | pub struct SelectAssignOpIr {
  type SliceOpIr (line 888) | pub struct SliceOpIr {
  type SliceAssignOpIr (line 896) | pub struct SliceAssignOpIr {
  type MaskWhereOpIr (line 905) | pub struct MaskWhereOpIr {
  type MaskFillOpIr (line 914) | pub struct MaskFillOpIr {
  type ClampOpIr (line 923) | pub struct ClampOpIr {
  type RepeatDimOpIr (line 932) | pub struct RepeatDimOpIr {
  type CatOpIr (line 941) | pub struct CatOpIr {
  type ReduceDimWithIndicesOpIr (line 949) | pub struct ReduceDimWithIndicesOpIr {
  type EmbeddingOpIr (line 958) | pub struct EmbeddingOpIr {
  type EmbeddingBackwardOpIr (line 966) | pub struct EmbeddingBackwardOpIr {
  type Conv1dOpIr (line 975) | pub struct Conv1dOpIr {
  type Conv1dXBackwardOpIr (line 985) | pub struct Conv1dXBackwardOpIr {
  type Conv1dWeightBackwardOpIr (line 995) | pub struct Conv1dWeightBackwardOpIr {
  type Conv1dBiasBackwardOpIr (line 1005) | pub struct Conv1dBiasBackwardOpIr {
  type Conv2dOpIr (line 1014) | pub struct Conv2dOpIr {
  type Conv2dXBackwardOpIr (line 1024) | pub struct Conv2dXBackwardOpIr {
  type Conv2dWeightBackwardOpIr (line 1034) | pub struct Conv2dWeightBackwardOpIr {
  type Conv2dBiasBackwardOpIr (line 1044) | pub struct Conv2dBiasBackwardOpIr {
  type DeformConv2dOpIr (line 1053) | pub struct DeformConv2dOpIr {
  type DeformConv2dBackwardOpIr (line 1065) | pub struct DeformConv2dBackwardOpIr {
  type Conv3dOpIr (line 1082) | pub struct Conv3dOpIr {
  type Conv3dXBackwardOpIr (line 1092) | pub struct Conv3dXBackwardOpIr {
  type Conv3dWeightBackwardOpIr (line 1102) | pub struct Conv3dWeightBackwardOpIr {
  type Conv3dBiasBackwardOpIr (line 1112) | pub struct Conv3dBiasBackwardOpIr {
  type ConvTranspose1dOpIr (line 1121) | pub struct ConvTranspose1dOpIr {
  type ConvTranspose2dOpIr (line 1131) | pub struct ConvTranspose2dOpIr {
  type ConvTranspose3dOpIr (line 1141) | pub struct ConvTranspose3dOpIr {
  type Conv1dOptionsIr (line 1151) | pub struct Conv1dOptionsIr {
    method from (line 1240) | fn from(value: ConvOptions<1>) -> Self {
  type Conv2dOptionsIr (line 1160) | pub struct Conv2dOptionsIr {
    method from (line 1251) | fn from(value: ConvOptions<2>) -> Self {
  type DeformableConv2dOptionsIr (line 1169) | pub struct DeformableConv2dOptionsIr {
    method from (line 1273) | fn from(value: DeformConvOptions<2>) -> Self {
  type Conv3dOptionsIr (line 1179) | pub struct Conv3dOptionsIr {
    method from (line 1262) | fn from(value: ConvOptions<3>) -> Self {
  type ConvTranspose1dOptionsIr (line 1188) | pub struct ConvTranspose1dOptionsIr {
    method from (line 1285) | fn from(value: ConvTransposeOptions<1>) -> Self {
  type ConvTranspose2dOptionsIr (line 1198) | pub struct ConvTranspose2dOptionsIr {
    method from (line 1297) | fn from(value: ConvTransposeOptions<2>) -> Self {
  type ConvTranspose3dOptionsIr (line 1208) | pub struct ConvTranspose3dOptionsIr {
    method from (line 1309) | fn from(value: ConvTransposeOptions<3>) -> Self {
  type QuantizationParametersIr (line 1218) | pub struct QuantizationParametersIr {
  type QuantizeOpIr (line 1225) | pub struct QuantizeOpIr {
  type DequantizeOpIr (line 1234) | pub struct DequantizeOpIr {
  function from (line 1321) | fn from(val: Conv1dOptionsIr) -> Self {
  function from (line 1332) | fn from(val: Conv2dOptionsIr) -> Self {
  function from (line 1343) | fn from(val: Conv3dOptionsIr) -> Self {
  function from (line 1354) | fn from(value: DeformableConv2dOptionsIr) -> Self {
  function from (line 1366) | fn from(val: ConvTranspose1dOptionsIr) -> Self {
  function from (line 1378) | fn from(val: ConvTranspose2dOptionsIr) -> Self {
  function from (line 1390) | fn from(val: ConvTranspose3dOptionsIr) -> Self {
  type AvgPool1dOpIr (line 1403) | pub struct AvgPool1dOpIr {
  type AvgPool2dOpIr (line 1415) | pub struct AvgPool2dOpIr {
  type AvgPool1dBackwardOpIr (line 1427) | pub struct AvgPool1dBackwardOpIr {
  type AvgPool2dBackwardOpIr (line 1440) | pub struct AvgPool2dBackwardOpIr {
  type AdaptiveAvgPool1dOpIr (line 1453) | pub struct AdaptiveAvgPool1dOpIr {
  type AdaptiveAvgPool2dOpIr (line 1461) | pub struct AdaptiveAvgPool2dOpIr {
  type AdaptiveAvgPool1dBackwardOpIr (line 1469) | pub struct AdaptiveAvgPool1dBackwardOpIr {
  type AdaptiveAvgPool2dBackwardOpIr (line 1477) | pub struct AdaptiveAvgPool2dBackwardOpIr {
  type MaxPool1dOpIr (line 1485) | pub struct MaxPool1dOpIr {
  type MaxPool1dWithIndicesOpIr (line 1497) | pub struct MaxPool1dWithIndicesOpIr {
  type MaxPool1dWithIndicesBackwardOpIr (line 1510) | pub struct MaxPool1dWithIndicesBackwardOpIr {
  type MaxPool2dOpIr (line 1524) | pub struct MaxPool2dOpIr {
  type MaxPool2dWithIndicesOpIr (line 1536) | pub struct MaxPool2dWithIndicesOpIr {
  type MaxPool2dWithIndicesBackwardOpIr (line 1549) | pub struct MaxPool2dWithIndicesBackwardOpIr {
  type InterpolateModeIr (line 1563) | pub enum InterpolateModeIr {
    method from (line 1644) | fn from(val: InterpolateMode) -> Self {
  type InterpolateOptionsIr (line 1572) | pub struct InterpolateOptionsIr {
    method from (line 1655) | fn from(val: InterpolateOptions) -> Self {
  type InterpolateOpIr (line 1579) | pub struct InterpolateOpIr {
  type AttentionOptionsIr (line 1588) | pub struct AttentionOptionsIr {
    method from (line 1605) | fn from(ir: AttentionModuleOptions) -> Self {
  method from (line 1595) | fn from(ir: AttentionOptionsIr) -> Self {
  type AttentionOpIr (line 1616) | pub struct AttentionOpIr {
  method from (line 1627) | fn from(val: InterpolateModeIr) -> Self {
  method from (line 1638) | fn from(val: InterpolateOptionsIr) -> Self {
  type InterpolateBackwardOpIr (line 1665) | pub struct InterpolateBackwardOpIr {
  type GridSamplePaddingModeIr (line 1675) | pub enum GridSamplePaddingModeIr {
    method from (line 1709) | fn from(val: GridSamplePaddingMode) -> Self {
  type GridSampleOptionsIr (line 1683) | pub struct GridSampleOptionsIr {
    method from (line 1729) | fn from(val: GridSampleOptions) -> Self {
  type GridSample2dOpIr (line 1691) | pub struct GridSample2dOpIr {
  method from (line 1699) | fn from(val: GridSamplePaddingModeIr) -> Self {
  method from (line 1719) | fn from(val: GridSampleOptionsIr) -> Self {
  method mark_read_only (line 2983) | fn mark_read_only(&mut self, nodes: &[TensorId], output: &mut Vec<Tensor...
  type OperationOutput (line 3005) | pub trait OperationOutput<O> {
    method output (line 3007) | fn output(self) -> O;
    method outputs (line 3010) | fn outputs<const N: usize>(self) -> [O; N];
  function output (line 3014) | fn output(self) -> O {
  function outputs (line 3019) | fn outputs<const N: usize>(self) -> [O; N] {

FILE: crates/burn-ir/src/scalar.rs
  type ScalarIr (line 9) | pub enum ScalarIr {
    method new (line 29) | pub fn new<E: ElementConversion>(value: E, dtype: &DType) -> Self {
    method elem (line 44) | pub fn elem<E: Element>(self) -> E {
    method from (line 58) | fn from(value: Scalar) -> Self {
  method hash (line 17) | fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
  method from (line 69) | fn from(value: ScalarIr) -> Self {

FILE: crates/burn-ir/src/tensor.rs
  type TensorId (line 7) | pub struct TensorId {
    method fmt (line 12) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method new (line 52) | pub fn new(value: u64) -> Self {
  type TensorStatus (line 19) | pub enum TensorStatus {
  type TensorIr (line 39) | pub struct TensorIr {
    method uninit (line 59) | pub fn uninit(id: TensorId, shape: Shape, dtype: DType) -> Self {

FILE: crates/burn-ndarray/build.rs
  function main (line 1) | fn main() {

FILE: crates/burn-ndarray/src/backend.rs
  type NdArrayDevice (line 21) | pub enum NdArrayDevice {
    method from_id (line 30) | fn from_id(_device_id: DeviceId) -> Self {
    method to_id (line 34) | fn to_id(&self) -> DeviceId {
    method device_count (line 41) | fn device_count(_type_id: u16) -> usize {
  type NdArray (line 51) | pub struct NdArray<E = f32, I = i64, Q = i8>
  type Device (line 66) | type Device = NdArrayDevice;
  type FloatTensorPrimitive (line 68) | type FloatTensorPrimitive = NdArrayTensor;
  type FloatElem (line 69) | type FloatElem = E;
  type IntTensorPrimitive (line 71) | type IntTensorPrimitive = NdArrayTensor;
  type IntElem (line 72) | type IntElem = I;
  type BoolTensorPrimitive (line 74) | type BoolTensorPrimitive = NdArrayTensor;
  type BoolElem (line 75) | type BoolElem = bool;
  type QuantizedTensorPrimitive (line 77) | type QuantizedTensorPrimitive = NdArrayQTensor;
  method ad_enabled (line 79) | fn ad_enabled(_device: &Self::Device) -> bool {
  method name (line 83) | fn name(_device: &Self::Device) -> String {
  method seed (line 87) | fn seed(_device: &Self::Device, seed: u64) {
  method dtype_usage (line 93) | fn dtype_usage(_device: &Self::Device, dtype: DType) -> burn_backend::DT...
  type Handle (line 140) | type Handle = HandleKind<Self>;
  method float_tensor (line 142) | fn float_tensor(handle: TensorHandle<Self::Handle>) -> FloatTensor<Self> {
  method int_tensor (line 149) | fn int_tensor(handle: TensorHandle<Self::Handle>) -> IntTensor<Self> {
  method bool_tensor (line 156) | fn bool_tensor(handle: TensorHandle<Self::Handle>) -> BoolTensor<Self> {
  method quantized_tensor (line 163) | fn quantized_tensor(handle: TensorHandle<Self::Handle>) -> QuantizedTens...
  method float_tensor_handle (line 170) | fn float_tensor_handle(tensor: FloatTensor<Self>) -> Self::Handle {
  method int_tensor_handle (line 174) | fn int_tensor_handle(tensor: IntTensor<Self>) -> Self::Handle {
  method bool_tensor_handle (line 178) | fn bool_tensor_handle(tensor: BoolTensor<Self>) -> Self::Handle {
  method quantized_tensor_handle (line 182) | fn quantized_tensor_handle(tensor: QuantizedTensor<Self>) -> Self::Handle {
  function should_support_dtypes (line 193) | fn should_support_dtypes() {

FILE: crates/burn-ndarray/src/element.rs
  type FloatNdArrayElement (line 13) | pub trait FloatNdArrayElement: NdArrayElement + Signed + core::cmp::Part...
  type IntNdArrayElement (line 20) | pub trait IntNdArrayElement: NdArrayElement + core::cmp::PartialOrd<Self...
  type NdArrayElement (line 23) | pub trait NdArrayElement:
  type ExpElement (line 37) | pub trait ExpElement {
    method exp_elem (line 39) | fn exp_elem(self) -> Self;
    method log_elem (line 41) | fn log_elem(self) -> Self;
    method log1p_elem (line 43) | fn log1p_elem(self) -> Self;
    method powf_elem (line 45) | fn powf_elem(self, value: f32) -> Self;
    method powi_elem (line 47) | fn powi_elem(self, value: i32) -> Self;
    method sqrt_elem (line 49) | fn sqrt_elem(self) -> Self;
    method abs_elem (line 51) | fn abs_elem(self) -> Self;
  type AddAssignElement (line 55) | pub trait AddAssignElement<Rhs = Self> {
    method add_assign (line 59) | fn add_assign(&mut self, rhs: Rhs);
    method add_assign (line 63) | fn add_assign(&mut self, rhs: Self) {
    method add_assign (line 69) | fn add_assign(&mut self, rhs: Self) {
  type QuantElement (line 75) | pub trait QuantElement: NdArrayElement {}

FILE: crates/burn-ndarray/src/ops/activation.rs
  function relu (line 15) | fn relu(tensor: FloatTensor<Self>) -> FloatTensor<Self> {

FILE: crates/burn-ndarray/src/ops/adaptive_avgpool.rs
  function adaptive_avg_pool2d (line 11) | pub(crate) fn adaptive_avg_pool2d<E: FloatNdArrayElement>(
  function adaptive_avg_pool2d_backward (line 54) | pub(crate) fn adaptive_avg_pool2d_backward<E: FloatNdArrayElement>(
  function start_index (line 94) | fn start_index(output_size_index: usize, output_size: usize, input_size:...
  function end_index (line 98) | fn end_index(output_size_index: usize, output_size: usize, input_size: u...

FILE: crates/burn-ndarray/src/ops/avgpool.rs
  function avg_pool2d (line 9) | pub(crate) fn avg_pool2d<E: FloatNdArrayElement>(
  function avg_pool2d_backward (line 101) | pub(crate) fn avg_pool2d_backward<E: FloatNdArrayElement>(

FILE: crates/burn-ndarray/src/ops/base.rs
  type NdArrayOps (line 49) | pub struct NdArrayOps<E> {
  type NdArrayMathOps (line 53) | pub(crate) struct NdArrayMathOps<E> {
  function slice (line 61) | pub fn slice(tensor: ArrayView<E, IxDyn>, slices: &[Slice]) -> SharedArr...
  function slice_assign (line 66) | pub fn slice_assign(
  function mask_where (line 77) | pub fn mask_where(
  function mask_fill (line 91) | pub fn mask_fill(tensor: SharedArray<E>, mask: SharedArray<bool>, value:...
  function gather (line 105) | pub fn gather<I: NdArrayElement>(
  function scatter (line 139) | pub fn scatter<I: NdArrayElement>(
  function gather_batch_size (line 189) | fn gather_batch_size(shape_tensor: &[usize], shape_indices: &[usize]) ->...
  function reshape (line 207) | pub fn reshape(tensor: SharedArray<E>, shape: Shape) -> SharedArray<E> {
  function concatenate (line 216) | pub(crate) fn concatenate(
  function cat (line 230) | pub fn cat(tensors: Vec<SharedArray<E>>, dim: usize) -> SharedArray<E> {
  function to_slice_args_with_steps (line 236) | fn to_slice_args_with_steps(
  function swap_dims (line 279) | pub fn swap_dims(mut tensor: SharedArray<E>, dim1: usize, dim2: usize) -...
  function permute (line 285) | pub fn permute(tensor: SharedArray<E>, axes: &[usize]) -> SharedArray<E> {
  function expand (line 290) | pub(crate) fn expand(tensor: SharedArray<E>, shape: Shape) -> SharedArra...
  function flip (line 300) | pub fn flip(tensor: SharedArray<E>, axes: &[usize]) -> SharedArray<E> {
  function unfold (line 346) | pub(crate) fn unfold(
  function broadcast_for_comparison (line 524) | fn broadcast_for_comparison<'a, E: Copy, S1, S2>(
  function add (line 587) | pub fn add(lhs: SharedArray<E>, rhs: SharedArray<E>) -> SharedArray<E> {
  function add_scalar (line 596) | pub fn add_scalar(lhs: SharedArray<E>, rhs: E) -> SharedArray<E> {
  function sub (line 618) | pub fn sub(lhs: SharedArray<E>, rhs: SharedArray<E>) -> SharedArray<E> {
  function sub_scalar (line 627) | pub fn sub_scalar(lhs: SharedArray<E>, rhs: E) -> SharedArray<E> {
  function mul (line 649) | pub fn mul(lhs: SharedArray<E>, rhs: SharedArray<E>) -> SharedArray<E> {
  function mul_scalar (line 657) | pub fn mul_scalar(lhs: SharedArray<E>, rhs: E) -> SharedArray<E> {
  function div (line 676) | pub fn div(lhs: SharedArray<E>, rhs: SharedArray<E>) -> SharedArray<E> {
  function div_scalar (line 683) | pub fn div_scalar(lhs: SharedArray<E>, rhs: E) -> SharedArray<E> {
  function remainder (line 690) | pub fn remainder(lhs: SharedArray<E>, rhs: SharedArray<E>) -> SharedArra...
  function remainder_scalar (line 703) | pub fn remainder_scalar(lhs: SharedArray<E>, rhs: E) -> SharedArray<E>
  function recip (line 711) | pub fn recip(tensor: SharedArray<E>) -> SharedArray<E> {
  function sum_view (line 719) | pub fn sum_view(view: ArrayView<'_, E, IxDyn>) -> SharedArray<E> {
  function mean_view (line 725) | pub fn mean_view(view: ArrayView<'_, E, IxDyn>) -> SharedArray<E> {
  function prod_view (line 731) | pub fn prod_view(view: ArrayView<'_, E, IxDyn>) -> SharedArray<E> {
  function mean_dim (line 736) | pub fn mean_dim(tensor: SharedArray<E>, dim: usize) -> SharedArray<E> {
  function sum_dim (line 744) | pub fn sum_dim(tensor: SharedArray<E>, dim: usize) -> SharedArray<E> {
  function prod_dim (line 752) | pub fn prod_dim(tensor: SharedArray<E>, dim: usize) -> SharedArray<E> {
  function cumsum (line 760) | pub fn cumsum(tensor: SharedArray<E>, dim: usize) -> SharedArray<E> {
  function cumprod (line 764) | pub fn cumprod(tensor: SharedArray<E>, dim: usize) -> SharedArray<E> {
  function select (line 768) | pub fn select<I: NdArrayElement>(
  function select_assign (line 784) | pub fn select_assign<I: NdArrayElement>(
  function elementwise_op (line 802) | pub(crate) fn elementwise_op<OtherE>(
  function elementwise_op_scalar (line 813) | pub(crate) fn elementwise_op_scalar(
  function abs (line 820) | pub(crate) fn abs(tensor: SharedArray<E>) -> SharedArray<E> {
  function equal (line 826) | pub(crate) fn equal(lhs: SharedArray<E>, rhs: SharedArray<E>) -> SharedA...
  function equal_elem (line 840) | pub(crate) fn equal_elem(lhs: SharedArray<E>, rhs: E) -> SharedArray<boo...
  function sign_op (line 861) | pub(crate) fn sign_op(tensor: SharedArray<E>) -> SharedArray<E>
  function max_view (line 888) | pub fn max_view(view: ArrayView<'_, E, IxDyn>) -> SharedArray<E> {
  function min_view (line 898) | pub fn min_view(view: ArrayView<'_, E, IxDyn>) -> SharedArray<E> {
  function argmax_view (line 908) | pub fn argmax_view<I: NdArrayElement + PartialOrd>(
  function argmin_view (line 916) | pub fn argmin_view<I: NdArrayElement + PartialOrd>(
  function cummin (line 923) | pub fn cummin(tensor: SharedArray<E>, dim: usize) -> SharedArray<E> {
  function cummax (line 927) | pub fn cummax(tensor: SharedArray<E>, dim: usize) -> SharedArray<E> {
  function argmax (line 931) | pub fn argmax<I: NdArrayElement + PartialOrd>(
  function argmin (line 938) | pub fn argmin<I: NdArrayElement + PartialOrd>(
  function clamp_min (line 945) | pub fn clamp_min(tensor: SharedArray<E>, min: E) -> SharedArray<E> {
  function clamp_max (line 971) | pub fn clamp_max(tensor: SharedArray<E>, max: E) -> SharedArray<E> {
  function clamp (line 997) | pub fn clamp(tensor: SharedArray<E>, min: E, max: E) -> SharedArray<E> {
  function greater (line 1026) | pub(crate) fn greater(lhs: SharedArray<E>, rhs: SharedArray<E>) -> Share...
  function greater_elem (line 1040) | pub(crate) fn greater_elem(lhs: SharedArray<E>, rhs: E) -> SharedArray<b...
  function greater_equal (line 1061) | pub(crate) fn greater_equal(lhs: SharedArray<E>, rhs: SharedArray<E>) ->...
  function greater_equal_elem (line 1088) | pub(crate) fn greater_equal_elem(lhs: SharedArray<E>, rhs: E) -> SharedA...
  function lower_equal (line 1109) | pub(crate) fn lower_equal(lhs: SharedArray<E>, rhs: SharedArray<E>) -> S...
  function lower_equal_elem (line 1123) | pub(crate) fn lower_equal_elem(lhs: SharedArray<E>, rhs: E) -> SharedArr...
  function lower (line 1144) | pub(crate) fn lower(lhs: SharedArray<E>, rhs: SharedArray<E>) -> SharedA...
  function lower_elem (line 1159) | pub(crate) fn lower_elem(lhs: SharedArray<E>, rhs: E) -> SharedArray<boo...
  type NdArrayBitOps (line 1181) | pub struct NdArrayBitOps<I: IntNdArrayElement>(PhantomData<I>);
  function bitand (line 1184) | pub(crate) fn bitand(lhs: SharedArray<I>, rhs: SharedArray<I>) -> Shared...
  function bitand_scalar (line 1193) | pub(crate) fn bitand_scalar(lhs: SharedArray<I>, rhs: I) -> SharedArray<...
  function bitor (line 1214) | pub(crate) fn bitor(lhs: SharedArray<I>, rhs: SharedArray<I>) -> SharedA...
  function bitor_scalar (line 1223) | pub(crate) fn bitor_scalar(lhs: SharedArray<I>, rhs: I) -> SharedArray<I> {
  function bitxor (line 1244) | pub(crate) fn bitxor(lhs: SharedArray<I>, rhs: SharedArray<I>) -> Shared...
  function bitxor_scalar (line 1253) | pub(crate) fn bitxor_scalar(lhs: SharedArray<I>, rhs: I) -> SharedArray<...
  function bitnot (line 1274) | pub(crate) fn bitnot(tensor: SharedArray<I>) -> SharedArray<I> {
  type NdArrayBoolOps (line 1282) | pub struct NdArrayBoolOps;
    method equal (line 1287) | pub(crate) fn equal(lhs: SharedArray<bool>, rhs: SharedArray<bool>) ->...
    method equal_elem (line 1303) | pub(crate) fn equal_elem(lhs: SharedArray<bool>, rhs: bool) -> SharedA...
    method and (line 1313) | pub(crate) fn and(lhs: SharedArray<bool>, rhs: SharedArray<bool>) -> S...
    method or (line 1329) | pub(crate) fn or(lhs: SharedArray<bool>, rhs: SharedArray<bool>) -> Sh...
    method any_view (line 1346) | pub fn any_view(view: ArrayView<'_, bool, IxDyn>) -> bool {
    method all_view (line 1351) | pub fn all_view(view: ArrayView<'_, bool, IxDyn>) -> bool {
  type CmpType (line 1356) | enum CmpType {
  function arg (line 1361) | fn arg<E: NdArrayElement + PartialOrd, I: NdArrayElement + PartialOrd>(
  function arg_view (line 1370) | fn arg_view<E: NdArrayElement + PartialOrd, I: NdArrayElement + PartialO...
  function should_generate_row_major_layout_for_cat (line 1406) | fn should_generate_row_major_layout_for_cat() {

FILE: crates/burn-ndarray/src/ops/bool_tensor.rs
  function bool_from_data (line 29) | fn bool_from_data(data: TensorData, _device: &NdArrayDevice) -> NdArrayT...
  function bool_into_data (line 36) | async fn bool_into_data(tensor: NdArrayTensor) -> Result<TensorData, Exe...
  function bool_to_device (line 40) | fn bool_to_device(tensor: NdArrayTensor, _device: &NdArrayDevice) -> NdA...
  function bool_reshape (line 44) | fn bool_reshape(tensor: NdArrayTensor, shape: Shape) -> NdArrayTensor {
  function bool_slice (line 48) | fn bool_slice(tensor: NdArrayTensor, slices: &[burn_backend::Slice]) -> ...
  function bool_into_int (line 52) | fn bool_into_int(tensor: NdArrayTensor) -> NdArrayTensor {
  function bool_device (line 58) | fn bool_device(_tensor: &NdArrayTensor) -> <NdArray<E> as Backend>::Devi...
  function bool_empty (line 62) | fn bool_empty(shape: Shape, _device: &<NdArray<E> as Backend>::Device) -...
  function bool_zeros (line 66) | fn bool_zeros(shape: Shape, _device: &<NdArray<E> as Backend>::Device) -...
  function bool_ones (line 71) | fn bool_ones(shape: Shape, _device: &<NdArray<E> as Backend>::Device) ->...
  function bool_slice_assign (line 76) | fn bool_slice_assign(
  function bool_cat (line 84) | fn bool_cat(tensors: Vec<NdArrayTensor>, dim: usize) -> NdArrayTensor {
  function bool_equal (line 88) | fn bool_equal(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function bool_not (line 92) | fn bool_not(tensor: NdArrayTensor) -> NdArrayTensor {
  function bool_and (line 96) | fn bool_and(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function bool_or (line 100) | fn bool_or(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function bool_into_float (line 104) | fn bool_into_float(tensor: NdArrayTensor) -> FloatTensor<Self> {
  function bool_swap_dims (line 109) | fn bool_swap_dims(tensor: NdArrayTensor, dim1: usize, dim2: usize) -> Nd...
  function bool_permute (line 113) | fn bool_permute(tensor: NdArrayTensor, axes: &[usize]) -> NdArrayTensor {
  function bool_expand (line 117) | fn bool_expand(tensor: NdArrayTensor, shape: Shape) -> NdArrayTensor {
  function bool_select (line 121) | fn bool_select(tensor: NdArrayTensor, dim: usize, indices: NdArrayTensor...
  function bool_select_or (line 134) | fn bool_select_or(
  function bool_flip (line 155) | fn bool_flip(tensor: NdArrayTensor, axes: &[usize]) -> NdArrayTensor {
  function bool_unfold (line 159) | fn bool_unfold(tensor: NdArrayTensor, dim: usize, size: usize, step: usi...
  function bool_mask_where (line 163) | fn bool_mask_where(
  function bool_mask_fill (line 171) | fn bool_mask_fill(
  function bool_gather (line 179) | fn bool_gather(
  function bool_scatter_or (line 191) | fn bool_scatter_or(
  function bool_equal_elem (line 205) | fn bool_equal_elem(lhs: BoolTensor<Self>, rhs: Scalar) -> BoolTensor<Sel...
  function bool_any (line 209) | fn bool_any(tensor: BoolTensor<Self>) -> BoolTensor<Self> {
  function bool_all (line 215) | fn bool_all(tensor: BoolTensor<Self>) -> BoolTensor<Self> {

FILE: crates/burn-ndarray/src/ops/conv.rs
  function conv2d_mad_inner (line 21) | fn conv2d_mad_inner<E: NdArrayElement>(
  function conv3d_mad_inner (line 59) | fn conv3d_mad_inner<E: NdArrayElement>(
  function conv2d (line 101) | pub(crate) fn conv2d<E: NdArrayElement>(
  function conv_transpose2d (line 223) | pub(crate) fn conv_transpose2d<E: NdArrayElement>(
  function conv3d (line 316) | pub(crate) fn conv3d<E: NdArrayElement>(
  function conv_transpose3d (line 459) | pub(crate) fn conv_transpose3d<E: NdArrayElement>(

FILE: crates/burn-ndarray/src/ops/deform_conv.rs
  function deform_im2col_kernel (line 18) | fn deform_im2col_kernel<F: FloatNdArrayElement>(
  function bilinear_interpolate (line 54) | fn bilinear_interpolate<F: FloatNdArrayElement>(
  function deform_conv2d (line 109) | pub(crate) fn deform_conv2d<F: FloatNdArrayElement>(
  function deform_im2col (line 191) | pub(crate) fn deform_im2col<F: FloatNdArrayElement>(
  type DeformConv2dBackward (line 262) | pub(crate) type DeformConv2dBackward<F> = (
  function deform_conv2d_backward (line 271) | pub(crate) fn deform_conv2d_backward<F: FloatNdArrayElement>(
  function compute_weight_grad (line 345) | fn compute_weight_grad<F: FloatNdArrayElement>(
  type InputGradients (line 378) | type InputGradients<F> = (SharedArray<F>, SharedArray<F>, Option<SharedA...
  function backward_gradient_inputs (line 380) | fn backward_gradient_inputs<F: FloatNdArrayElement>(
  function compute_offset_and_mask_gradient (line 427) | fn compute_offset_and_mask_gradient<F: FloatNdArrayElement>(
  function get_coordinate_weight (line 517) | fn get_coordinate_weight<F: FloatNdArrayElement>(
  function compute_input_grad (line 568) | fn compute_input_grad<F: FloatNdArrayElement>(
  function deform_col2img_kernel (line 627) | fn deform_col2img_kernel(

FILE: crates/burn-ndarray/src/ops/grid_sample.rs
  function grid_sample_2d (line 24) | pub(crate) fn grid_sample_2d<E: FloatNdArrayElement>(
  function bilinear_interpolate (line 101) | fn bilinear_interpolate<E, S>(
  function reflect_coordinate (line 196) | fn reflect_coordinate(coord: f64, size: usize, align_corners: bool) -> f...

FILE: crates/burn-ndarray/src/ops/int_tensor.rs
  function int_from_data (line 29) | fn int_from_data(data: TensorData, _device: &NdArrayDevice) -> NdArrayTe...
  function int_into_data (line 37) | async fn int_into_data(tensor: NdArrayTensor) -> Result<TensorData, Exec...
  function int_to_device (line 41) | fn int_to_device(tensor: NdArrayTensor, _device: &NdArrayDevice) -> NdAr...
  function int_reshape (line 45) | fn int_reshape(tensor: NdArrayTensor, shape: Shape) -> NdArrayTensor {
  function int_slice (line 49) | fn int_slice(tensor: NdArrayTensor, slices: &[burn_backend::Slice]) -> N...
  function int_device (line 53) | fn int_device(_tensor: &NdArrayTensor) -> <NdArray<E> as Backend>::Device {
  function int_empty (line 57) | fn int_empty(
  function int_matmul (line 65) | fn int_matmul(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  function int_mask_where (line 69) | fn int_mask_where(
  function int_mask_fill (line 79) | fn int_mask_fill(tensor: NdArrayTensor, mask: NdArrayTensor, value: Scal...
  function int_slice_assign (line 87) | fn int_slice_assign(
  function int_cat (line 97) | fn int_cat(tensors: Vec<NdArrayTensor>, dim: usize) -> NdArrayTensor {
  function int_equal (line 101) | fn int_equal(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function int_equal_elem (line 105) | fn int_equal_elem(lhs: NdArrayTensor, rhs: Scalar) -> NdArrayTensor {
  function int_greater (line 109) | fn int_greater(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function int_greater_elem (line 113) | fn int_greater_elem(lhs: NdArrayTensor, rhs: Scalar) -> NdArrayTensor {
  function int_greater_equal (line 117) | fn int_greater_equal(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayT...
  function int_greater_equal_elem (line 121) | fn int_greater_equal_elem(lhs: NdArrayTensor, rhs: Scalar) -> NdArrayTen...
  function int_lower (line 128) | fn int_lower(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function int_lower_elem (line 132) | fn int_lower_elem(lhs: NdArrayTensor, rhs: Scalar) -> NdArrayTensor {
  function int_lower_equal (line 136) | fn int_lower_equal(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTen...
  function int_lower_equal_elem (line 140) | fn int_lower_equal_elem(lhs: NdArrayTensor, rhs: Scalar) -> NdArrayTensor {
  function int_add (line 147) | fn int_add(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function int_add_scalar (line 151) | fn int_add_scalar(lhs: NdArrayTensor, rhs: Scalar) -> NdArrayTensor {
  function int_sub (line 155) | fn int_sub(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function int_sub_scalar (line 159) | fn int_sub_scalar(lhs: NdArrayTensor, rhs: Scalar) -> NdArrayTensor {
  function int_mul (line 163) | fn int_mul(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function int_mul_scalar (line 167) | fn int_mul_scalar(lhs: NdArrayTensor, rhs: Scalar) -> NdArrayTensor {
  function int_div (line 171) | fn int_div(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function int_div_scalar (line 175) | fn int_div_scalar(lhs: NdArrayTensor, rhs: Scalar) -> NdArrayTensor {
  function int_remainder (line 179) | fn int_remainder(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function int_remainder_scalar (line 183) | fn int_remainder_scalar(lhs: NdArrayTensor, rhs: Scalar) -> NdArrayTensor {
  function int_sum (line 190) | fn int_sum(tensor: NdArrayTensor) -> NdArrayTensor {
  function int_sum_dim (line 197) | fn int_sum_dim(tensor: NdArrayTensor, dim: usize) -> NdArrayTensor {
  function int_prod (line 201) | fn int_prod(tensor: NdArrayTensor) -> NdArrayTensor {
  function int_prod_dim (line 210) | fn int_prod_dim(tensor: NdArrayTensor, dim: usize) -> NdArrayTensor {
  function int_mean (line 214) | fn int_mean(tensor: NdArrayTensor) -> NdArrayTensor {
  function int_mean_dim (line 223) | fn int_mean_dim(tensor: NdArrayTensor, dim: usize) -> NdArrayTensor {
  function int_max (line 227) | fn int_max(tensor: NdArrayTensor) -> NdArrayTensor {
  function int_min (line 234) | fn int_min(tensor: NdArrayTensor) -> NdArrayTensor {
  function int_cumsum (line 241) | fn int_cumsum(tensor: NdArrayTensor, dim: usize) -> NdArrayTensor {
  function int_cumprod (line 245) | fn int_cumprod(tensor: NdArrayTensor, dim: usize) -> NdArrayTensor {
  function int_cummin (line 249) | fn int_cummin(tensor: NdArrayTensor, dim: usize) -> NdArrayTensor {
  function int_cummax (line 253) | fn int_cummax(tensor: NdArrayTensor, dim: usize) -> NdArrayTensor {
  function int_gather (line 257) | fn int_gather(dim: usize, tensor: NdArrayTensor, indices: NdArrayTensor)...
  function int_scatter_add (line 265) | fn int_scatter_add(
  function int_select (line 278) | fn int_select(tensor: NdArrayTensor, dim: usize, indices: NdArrayTensor)...
  function int_select_add (line 286) | fn int_select_add(
  function int_argmax (line 298) | fn int_argmax(tensor: NdArrayTensor, dim: usize) -> NdArrayTensor {
  function int_argmin (line 305) | fn int_argmin(tensor: NdArrayTensor, dim: usize) -> NdArrayTensor {
  function int_clamp_min (line 312) | fn int_clamp_min(tensor: NdArrayTensor, min: Scalar) -> NdArrayTensor {
  function int_clamp_max (line 316) | fn int_clamp_max(tensor: NdArrayTensor, max: Scalar) -> NdArrayTensor {
  function int_clamp (line 320) | fn int_clamp(tensor: NdArrayTensor, min: Scalar, max: Scalar) -> NdArray...
  function int_abs (line 328) | fn int_abs(tensor: NdArrayTensor) -> NdArrayTensor {
  function int_into_float (line 341) | fn int_into_float(tensor: NdArrayTensor) -> FloatTensor<Self> {
  function int_swap_dims (line 347) | fn int_swap_dims(tensor: NdArrayTensor, dim1: usize, dim2: usize) -> NdA...
  function int_random (line 351) | fn int_random(
  function int_powi (line 373) | fn int_powi(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function int_permute (line 381) | fn int_permute(tensor: NdArrayTensor, axes: &[usize]) -> NdArrayTensor {
  function int_flip (line 385) | fn int_flip(tensor: NdArrayTensor, axes: &[usize]) -> NdArrayTensor {
  function int_sign (line 389) | fn int_sign(tensor: NdArrayTensor) -> NdArrayTensor {
  function int_expand (line 403) | fn int_expand(tensor: NdArrayTensor, shape: Shape) -> NdArrayTensor {
  function bitwise_and (line 407) | fn bitwise_and(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function bitwise_and_scalar (line 411) | fn bitwise_and_scalar(lhs: NdArrayTensor, rhs: Scalar) -> NdArrayTensor {
  function bitwise_or (line 415) | fn bitwise_or(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function bitwise_or_scalar (line 419) | fn bitwise_or_scalar(lhs: NdArrayTensor, rhs: Scalar) -> NdArrayTensor {
  function bitwise_xor (line 423) | fn bitwise_xor(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArrayTensor {
  function bitwise_xor_scalar (line 427) | fn bitwise_xor_scalar(lhs: NdArrayTensor, rhs: Scalar) -> NdArrayTensor {
  function bitwise_not (line 431) | fn bitwise_not(tensor: NdArrayTensor) -> NdArrayTensor {
  function bitwise_left_shift (line 435) | fn bitwise_left_shift(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArray...
  function bitwise_left_shift_scalar (line 443) | fn bitwise_left_shift_scalar(lhs: NdArrayTensor, rhs: Scalar) -> NdArray...
  function bitwise_right_shift (line 451) | fn bitwise_right_shift(lhs: NdArrayTensor, rhs: NdArrayTensor) -> NdArra...
  function bitwise_right_shift_scalar (line 459) | fn bitwise_right_shift_scalar(lhs: NdArrayTensor, rhs: Scalar) -> NdArra...
  function int_cast (line 467) | fn int_cast(tensor: IntTensor<Self>, dtype: IntDType) -> IntTensor<Self> {
  function int_unfold (line 471) | fn int_unfold(

FILE: crates/burn-ndarray/src/ops/interpolate.rs
  function nearest_interpolate (line 9) | pub(crate) fn nearest_interpolate<E: FloatNdArrayElement>(
  function nearest_interpolate_backward (line 53) | pub(crate) fn nearest_interpolate_backward<E: FloatNdArrayElement>(
  function start_index (line 86) | fn start_index(output_size_index: usize, output_size: usize, input_size:...
  function ceil_clamp (line 91) | pub(crate) fn ceil_clamp(frac: f64, max: usize) -> f64 {
  function bilinear_interpolate (line 95) | pub(crate) fn bilinear_interpolate<E: FloatNdArrayElement>(
  function bicubic_interpolate (line 149) | pub(crate) fn bicubic_interpolate<E: FloatNdArrayElement>(
  function lanczos3_interpolate (line 260) | pub(crate) fn lanczos3_interpolate<E: FloatNdArrayElement>(
  function bilinear_interpolate_single (line 368) | pub(crate) fn bilinear_interpolate_single<E, S>(

FILE: crates/burn-ndarray/src/ops/macros.rs
  function mean_dim (line 43) | pub(crate) fn mean_dim<E: NdArrayElement>(tensor: SharedArray<E>, dim: u...
  function sum_dim (line 47) | pub(crate) fn sum_dim<E: NdArrayElement>(tensor: SharedArray<E>, dim: us...
  function prod_dim (line 51) | pub(crate) fn prod_dim<E: NdArrayElement>(tensor: SharedArray<E>, dim: u...
  function cumulative_with_op (line 58) | pub(crate) fn cumulative_with_op<E, F>(tensor: SharedArray<E>, dim: usiz...
  function cumsum_dim (line 79) | pub(crate) fn cumsum_dim<E: NdArrayElement>(tensor: SharedArray<E>, dim:...
  function cumprod_dim (line 83) | pub(crate) fn cumprod_dim<E: NdArrayElement>(tensor: SharedArray<E>, dim...
  function cummin_dim (line 87) | pub(crate) fn cummin_dim<E: NdArrayElement + core::cmp::PartialOrd<E>>(
  function cummax_dim (line 98) | pub(crate) fn cummax_dim<E: NdArrayElement + core::cmp::PartialOrd<E>>(

FILE: crates/burn-ndarray/src/ops/matmul.rs
  function matmul (line 9) | pub(crate) fn matmul<E: NdArrayElement>(
  type Strides (line 73) | struct Strides {
    method new (line 77) | fn new(strides: Vec<usize>) -> Self {
    method unflatten (line 81) | fn unflatten(&self, linear_index: usize) -> Vec<usize> {
    method flatten (line 91) | fn flatten(&self, index: &Vec<usize>) -> usize {
    method empty (line 272) | fn empty() -> Self {
  function output_shape (line 113) | fn output_shape(lsh: &[usize], rsh: &[usize]) -> (Shape, Strides, Stride...
  function cross (line 182) | pub(crate) fn cross<E: NdArrayElement>(
  function test_output_shape (line 280) | fn test_output_shape() {
  function test_output_shape_too_small (line 347) | fn test_output_shape_too_small() {
  function test_output_shape_bad_matrix_dims (line 353) | fn test_output_shape_bad_matrix_dims() {
  function test_output_shape_non_broadcast (line 359) | fn test_output_shape_non_broadcast() {

FILE: crates/burn-ndarray/src/ops/maxpool.rs
  function max_pool2d (line 14) | pub(crate) fn max_pool2d<E: FloatNdArrayElement>(
  function max_pool2d_with_indices (line 101) | pub(crate) fn max_pool2d_with_indices<E: FloatNdArrayElement, I: IntNdAr...
  function max_pool2d_backward (line 205) | pub(crate) fn max_pool2d_backward<E: FloatNdArrayElement, I: IntNdArrayE...

FILE: crates/burn-ndarray/src/ops/module.rs
  function conv2d (line 60) | fn conv2d(
  function deform_conv2d (line 76) | fn deform_conv2d(
  function deform_conv2d_backward (line 95) | fn deform_conv2d_backward(
  function conv_transpose2d (line 129) | fn conv_transpose2d(
  function avg_pool2d (line 140) | fn avg_pool2d(
  function avg_pool2d_backward (line 171) | fn avg_pool2d_backward(
  function max_pool2d (line 192) | fn max_pool2d(
  function max_pool2d_with_indices (line 215) | fn max_pool2d_with_indices(
  function max_pool2d_with_indices_backward (line 236) | fn max_pool2d_with_indices_backward(
  function adaptive_avg_pool2d (line 266) | fn adaptive_avg_pool2d(x: FloatTensor<Self>, output_size: [usize; 2]) ->...
  function adaptive_avg_pool2d_backward (line 274) | fn adaptive_avg_pool2d_backward(
  function interpolate (line 283) | fn interpolate(
  function interpolate_backward (line 326) | fn interpolate_backward(
  function conv3d (line 348) | fn conv3d(
  function conv_transpose3d (line 360) | fn conv_transpose3d(
  function attention (line 371) | fn attention(

FILE: crates/burn-ndarray/src/ops/padding.rs
  function apply_padding_4d (line 6) | pub(crate) fn apply_padding_4d<E: NdArrayElement>(
  function apply_padding_5d (line 36) | pub(crate) fn apply_padding_5d<E: NdArrayElement>(

FILE: crates/burn-ndarray/src/ops/qtensor.rs
  function q_from_data (line 28) | fn q_from_data(data: TensorData, _device: &NdArrayDevice) -> QuantizedTe...
  function quantize (line 84) | fn quantize(
  function dequantize (line 175) | fn dequantize(tensor: QuantizedTensor<Self>) -> FloatTensor<Self> {
  function q_device (line 189) | fn q_device(_tensor: &QuantizedTensor<Self>) -> NdArrayDevice {
  function q_to_device (line 193) | fn q_to_device(
  function q_reshape (line 200) | fn q_reshape(tensor: QuantizedTensor<Self>, shape: Shape) -> QuantizedTe...
  function q_into_data (line 210) | async fn q_into_data(tensor: QuantizedTensor<Self>) -> Result<TensorData...
  function q_swap_dims (line 223) | fn q_swap_dims(
  function q_permute (line 237) | fn q_permute(tensor: QuantizedTensor<Self>, axes: &[usize]) -> Quantized...
  function q_flip (line 247) | fn q_flip(tensor: QuantizedTensor<Self>, axes: &[usize]) -> QuantizedTen...
  function q_gather (line 257) | fn q_gather(
  function q_select (line 277) | fn q_select(
  function q_slice (line 297) | fn q_slice(
  function q_argmax (line 308) | fn q_argmax(tensor: QuantizedTensor<Self>, dim: usize) -> IntTensor<Self> {
  function q_argmin (line 314) | fn q_argmin(tensor: QuantizedTensor<Self>, dim: usize) -> IntTensor<Self> {
  function q_expand (line 320) | fn q_expand(tensor: QuantizedTensor<Self>, shape: Shape) -> QuantizedTen...
  function dequantize (line 331) | fn dequantize<Q: QuantElement>(

FILE: crates/burn-ndarray/src/ops/quantization.rs
  type QuantizationStrategy (line 11) | pub enum QuantizationStrategy {
    method quantize (line 20) | pub fn quantize(&self, values: &[f32]) -> Vec<i8> {
    method dequantize (line 42) | pub fn dequantize(&self, values: &[i8]) -> Vec<f32> {
  type Quantization (line 66) | pub trait Quantization<E: Float + Send + Sync> {
    method range (line 68) | fn range(&self) -> (E, E);
    method quantize (line 70) | fn quantize<Q: PrimInt>(&self, values: &[E]) -> Vec<Q>;
    method quantize_one (line 72) | fn quantize_one<Q: PrimInt>(&self, value: E) -> Q;
    method dequantize (line 74) | fn dequantize<Q: PrimInt>(&self, values: &[Q]) -> Vec<E>;
    method dequantize_one (line 76) | fn dequantize_one<Q: PrimInt>(&self, value: Q) -> E;
  function valid_scale (line 79) | fn valid_scale<E: Float>(mut scale: E) -> E {
  type SymmetricQuantization (line 90) | pub struct SymmetricQuantization<E: Float + Send + Sync> {
  function init (line 99) | pub fn init(scale: E, value: QuantValue) -> Self {
  function new (line 108) | fn new(alpha: E, beta: E, value: QuantValue) -> Self {
  function quantize (line 121) | fn quantize<Q: PrimInt>(&self, values: &[E]) -> Vec<Q> {
  function dequantize (line 125) | fn dequantize<Q: PrimInt>(&self, values: &[Q]) -> Vec<E> {
  function quantize_one (line 129) | fn quantize_one<Q: PrimInt>(&self, value: E) -> Q {
  function dequantize_one (line 136) | fn dequantize_one<Q: PrimInt>(&self, value: Q) -> E {
  function range (line 141) | fn range(&self) -> (E, E) {
  method eq (line 150) | fn eq(&self, other: &Self) -> bool {
  function test_int8_symmetric_quantization (line 165) | fn test_int8_symmetric_quantization() {
  function test_int8_symmetric_quantization_per_block (line 181) | fn test_int8_symmetric_quantization_per_block() {
  function should_support_dequantize (line 203) | fn should_support_dequantize() {

FILE: crates/burn-ndarray/src/ops/simd/avgpool.rs
  function is_accelerated (line 15) | fn is_accelerated<S: Simd, T: VAdd + VDiv>(_x: PhantomData<T>) -> bool {
  function try_avg_pool2d_simd (line 19) | pub(crate) fn try_avg_pool2d_simd<E: Element>(
  function cast (line 50) | fn cast<T, E>(tensor: SharedArray<T>) -> SharedArray<E> {
  constant BLOCK_REGISTERS (line 66) | const BLOCK_REGISTERS: usize = 8;
  function avg_pool_nhwc (line 68) | pub(crate) fn avg_pool_nhwc<E: Element + VAdd + VDiv>(
  function loop_blocked (line 155) | fn loop_blocked<'a, S: Simd, E: Element + VAdd + VDiv>(
  function loop_unblocked (line 280) | unsafe fn loop_unblocked<'a, S: Simd, E: Element + VAdd + VDiv>(
  function loop_scalar (line 370) | fn loop_scalar<E: Element + VAdd + VDiv>(

FILE: crates/burn-ndarray/src/ops/simd/base.rs
  function should_use_simd (line 17) | pub fn should_use_simd(len: usize) -> bool {
  function should_use_simd (line 32) | pub fn should_use_simd(_len: usize) -> bool {
  function should_use_simd (line 37) | pub fn should_use_simd(_len: usize) -> bool {
  function lanes (line 41) | pub(crate) fn lanes<E: Scalar>() -> usize {
  function lanes_simd (line 59) | fn lanes_simd<S: Simd, E: Scalar>(_ty: PhantomData<E>) -> usize {
  function uninit_array_like (line 63) | pub(crate) fn uninit_array_like<In, Out>(reference: &ArcArray<In, IxDyn>...
  type MinMax (line 74) | pub trait MinMax {
    method min (line 75) | fn min(self, other: Self) -> Self;
    method max (line 76) | fn max(self, other: Self) -> Self;
    method min (line 98) | fn min(self, other: Self) -> Self {
    method max (line 102) | fn max(self, other: Self) -> Self {
    method min (line 108) | fn min(self, other: Self) -> Self {
    method max (line 112) | fn max(self, other: Self) -> Self {

FILE: crates/burn-ndarray/src/ops/simd/binary.rs
  type SimdBinop (line 21) | pub trait SimdBinop<T: Scalar, Out: Scalar> {
    method apply_vec (line 22) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Vector<...
    method apply (line 23) | fn apply(lhs: T, rhs: T) -> Out;
    method is_accelerated (line 24) | fn is_accelerated<S: Simd>() -> bool;
  method apply_vec (line 28) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Vector<S,...
  method apply (line 32) | fn apply(lhs: T, rhs: T) -> T {
  method is_accelerated (line 36) | fn is_accelerated<S: Simd>() -> bool {
  method apply_vec (line 42) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Vector<S,...
  method apply (line 46) | fn apply(lhs: T, rhs: T) -> T {
  method is_accelerated (line 50) | fn is_accelerated<S: Simd>() -> bool {
  method apply_vec (line 56) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Vector<S,...
  method apply (line 60) | fn apply(lhs: T, rhs: T) -> T {
  method is_accelerated (line 64) | fn is_accelerated<S: Simd>() -> bool {
  method apply_vec (line 70) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Vector<S,...
  method apply (line 74) | fn apply(lhs: T, rhs: T) -> T {
  method is_accelerated (line 78) | fn is_accelerated<S: Simd>() -> bool {
  method apply_vec (line 84) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Vector<S,...
  method apply (line 88) | fn apply(lhs: T, rhs: T) -> T {
  method is_accelerated (line 92) | fn is_accelerated<S: Simd>() -> bool {
  method apply_vec (line 98) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Vector<S,...
  method apply (line 102) | fn apply(lhs: T, rhs: T) -> T {
  method is_accelerated (line 106) | fn is_accelerated<S: Simd>() -> bool {
  method apply_vec (line 112) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Vector<S,...
  method apply (line 116) | fn apply(lhs: T, rhs: T) -> T {
  method is_accelerated (line 120) | fn is_accelerated<S: Simd>() -> bool {
  method apply_vec (line 126) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Vector<S,...
  method apply (line 130) | fn apply(lhs: T, rhs: T) -> T {
  method is_accelerated (line 134) | fn is_accelerated<S: Simd>() -> bool {
  method apply_vec (line 140) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Vector<S,...
  method apply (line 144) | fn apply(lhs: T, rhs: T) -> T {
  method is_accelerated (line 148) | fn is_accelerated<S: Simd>() -> bool {
  function is_accelerated (line 154) | fn is_accelerated<S: Simd, T: Scalar, Out: Scalar, Op: SimdBinop<T, Out>>(
  function try_binary_simd (line 161) | pub fn try_binary_simd<
  function binary_simd_same (line 191) | fn binary_simd_same<
  function binary (line 228) | fn binary<
  function unsafe_alias_slice_mut (line 295) | fn unsafe_alias_slice_mut<'a, T>(slice: &mut [T]) -> &'a mut [T] {

FILE: crates/burn-ndarray/src/ops/simd/binary_elemwise.rs
  type ScalarSimdBinop (line 15) | pub trait ScalarSimdBinop<T: Scalar, Out: Scalar> {
    method splat (line 18) | fn splat<S: Simd>(rhs: Self::Rhs) -> Self::RhsVec<S>;
    method apply_vec (line 19) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Self::RhsVec<S>) -> Vect...
    method apply (line 20) | fn apply(lhs: T, rhs: Self::Rhs) -> Out;
    method is_accelerated (line 21) | fn is_accelerated<S: Simd>() -> bool;
  type VecAdd (line 24) | pub struct VecAdd;
    type Rhs (line 36) | type Rhs = T;
    type RhsVec (line 37) | type RhsVec<S: Simd> = Vector<S, T>;
    method splat (line 39) | fn splat<S: Simd>(rhs: Self::Rhs) -> Self::RhsVec<S> {
    method apply_vec (line 43) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Self::RhsVec<S>) -> Vect...
    method apply (line 47) | fn apply(lhs: T, rhs: T) -> T {
    method is_accelerated (line 51) | fn is_accelerated<S: Simd>() -> bool {
  type VecDiv (line 25) | pub struct VecDiv;
    type Rhs (line 57) | type Rhs = T;
    type RhsVec (line 58) | type RhsVec<S: Simd> = Vector<S, T>;
    method splat (line 60) | fn splat<S: Simd>(rhs: Self::Rhs) -> Self::RhsVec<S> {
    method apply_vec (line 64) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Self::RhsVec<S>) -> Vect...
    method apply (line 68) | fn apply(lhs: T, rhs: T) -> T {
    method is_accelerated (line 72) | fn is_accelerated<S: Simd>() -> bool {
  type VecMul (line 26) | pub struct VecMul;
    type Rhs (line 78) | type Rhs = T;
    type RhsVec (line 79) | type RhsVec<S: Simd> = Vector<S, T>;
    method splat (line 81) | fn splat<S: Simd>(rhs: Self::Rhs) -> Self::RhsVec<S> {
    method apply_vec (line 85) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Self::RhsVec<S>) -> Vect...
    method apply (line 89) | fn apply(lhs: T, rhs: T) -> T {
    method is_accelerated (line 93) | fn is_accelerated<S: Simd>() -> bool {
  type VecSub (line 27) | pub struct VecSub;
    type Rhs (line 99) | type Rhs = T;
    type RhsVec (line 100) | type RhsVec<S: Simd> = Vector<S, T>;
    method splat (line 102) | fn splat<S: Simd>(rhs: Self::Rhs) -> Self::RhsVec<S> {
    method apply_vec (line 106) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Self::RhsVec<S>) -> Vect...
    method apply (line 110) | fn apply(lhs: T, rhs: T) -> T {
    method is_accelerated (line 114) | fn is_accelerated<S: Simd>() -> bool {
  type VecMin (line 28) | pub struct VecMin;
    type Rhs (line 120) | type Rhs = T;
    type RhsVec (line 121) | type RhsVec<S: Simd> = Vector<S, T>;
    method splat (line 123) | fn splat<S: Simd>(rhs: Self::Rhs) -> Self::RhsVec<S> {
    method apply_vec (line 127) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Self::RhsVec<S>) -> Vect...
    method apply (line 131) | fn apply(lhs: T, rhs: T) -> T {
    method is_accelerated (line 135) | fn is_accelerated<S: Simd>() -> bool {
  type VecMax (line 29) | pub struct VecMax;
    type Rhs (line 141) | type Rhs = T;
    type RhsVec (line 142) | type RhsVec<S: Simd> = Vector<S, T>;
    method splat (line 144) | fn splat<S: Simd>(rhs: Self::Rhs) -> Self::RhsVec<S> {
    method apply_vec (line 148) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Self::RhsVec<S>) -> Vect...
    method apply (line 152) | fn apply(lhs: T, rhs: T) -> T {
    method is_accelerated (line 156) | fn is_accelerated<S: Simd>() -> bool {
  type VecClamp (line 30) | pub struct VecClamp;
    type Rhs (line 162) | type Rhs = (T, T);
    type RhsVec (line 163) | type RhsVec<S: Simd> = (Vector<S, T>, Vector<S, T>);
    method splat (line 165) | fn splat<S: Simd>((min, max): Self::Rhs) -> Self::RhsVec<S> {
    method apply_vec (line 169) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, (min, max): Self::RhsVec<S>) ...
    method apply (line 173) | fn apply(lhs: T, (min, max): Self::Rhs) -> T {
    method is_accelerated (line 177) | fn is_accelerated<S: Simd>() -> bool {
  type VecBitAnd (line 31) | pub struct VecBitAnd;
    type Rhs (line 183) | type Rhs = T;
    type RhsVec (line 184) | type RhsVec<S: Simd> = Vector<S, T>;
    method splat (line 186) | fn splat<S: Simd>(rhs: Self::Rhs) -> Self::RhsVec<S> {
    method apply_vec (line 190) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Self::RhsVec<S>) -> Vect...
    method apply (line 194) | fn apply(lhs: T, rhs: Self::Rhs) -> T {
    method is_accelerated (line 198) | fn is_accelerated<S: Simd>() -> bool {
  type VecBitOr (line 32) | pub struct VecBitOr;
    type Rhs (line 204) | type Rhs = T;
    type RhsVec (line 205) | type RhsVec<S: Simd> = Vector<S, T>;
    method splat (line 207) | fn splat<S: Simd>(rhs: Self::Rhs) -> Self::RhsVec<S> {
    method apply_vec (line 211) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Self::RhsVec<S>) -> Vect...
    method apply (line 215) | fn apply(lhs: T, rhs: Self::Rhs) -> T {
    method is_accelerated (line 219) | fn is_accelerated<S: Simd>() -> bool {
  type VecBitXor (line 33) | pub struct VecBitXor;
    type Rhs (line 225) | type Rhs = T;
    type RhsVec (line 226) | type RhsVec<S: Simd> = Vector<S, T>;
    method splat (line 228) | fn splat<S: Simd>(rhs: Self::Rhs) -> Self::RhsVec<S> {
    method apply_vec (line 232) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Self::RhsVec<S>) -> Vect...
    method apply (line 236) | fn apply(lhs: T, rhs: Self::Rhs) -> T {
    method is_accelerated (line 240) | fn is_accelerated<S: Simd>() -> bool {
  function is_accelerated (line 246) | fn is_accelerated<S: Simd, T: Scalar, Out: Scalar, Op: ScalarSimdBinop<T...
  function try_binary_scalar_simd (line 252) | pub fn try_binary_scalar_simd<
  function binary_scalar_simd_inplace (line 286) | unsafe fn binary_scalar_simd_inplace<
  function binary_scalar_simd_owned (line 303) | fn binary_scalar_simd_owned<
  function binary_scalar_slice (line 321) | fn binary_scalar_slice<
  function binary_scalar_slice_inplace (line 376) | unsafe fn binary_scalar_slice_inplace<

FILE: crates/burn-ndarray/src/ops/simd/cmp.rs
  type SimdCmpOp (line 12) | pub trait SimdCmpOp<T: Scalar> {
    method apply_vec (line 13) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Mask<S,...
    method apply (line 14) | fn apply(lhs: T, rhs: T) -> bool;
    method is_accelerated (line 15) | fn is_accelerated<S: Simd>() -> bool;
  type VecEquals (line 18) | pub struct VecEquals;
    method apply_vec (line 21) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Mask<S,...
    method apply (line 25) | fn apply(lhs: T, rhs: T) -> bool {
    method is_accelerated (line 29) | fn is_accelerated<S: Simd>() -> bool {
  type VecGreater (line 34) | pub struct VecGreater;
    method apply_vec (line 37) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Mask<S,...
    method apply (line 41) | fn apply(lhs: T, rhs: T) -> bool {
    method is_accelerated (line 45) | fn is_accelerated<S: Simd>() -> bool {
  type VecGreaterEq (line 50) | pub struct VecGreaterEq;
    method apply_vec (line 53) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Mask<S,...
    method apply (line 57) | fn apply(lhs: T, rhs: T) -> bool {
    method is_accelerated (line 61) | fn is_accelerated<S: Simd>() -> bool {
  type VecLowerEq (line 66) | pub struct VecLowerEq;
    method apply_vec (line 69) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Mask<S,...
    method apply (line 73) | fn apply(lhs: T, rhs: T) -> bool {
    method is_accelerated (line 77) | fn is_accelerated<S: Simd>() -> bool {
  type VecLower (line 82) | pub struct VecLower;
    method apply_vec (line 85) | fn apply_vec<S: Simd>(lhs: Vector<S, T>, rhs: Vector<S, T>) -> Mask<S,...
    method apply (line 89) | fn apply(lhs: T, rhs: T) -> bool {
    method is_accelerated (line 93) | fn is_accelerated<S: Simd>() -> bool {
  function is_accelerated (line 99) | fn is_accelerated<S: Simd, T: Scalar, Op: SimdCmpOp<T>>(_x: PhantomData<...
  function try_cmp_simd (line 104) | pub fn try_cmp_simd<E: Element, T: NdArrayElement + Scalar, Op: SimdCmpO...
  function cmp_simd_same (line 126) | fn cmp_simd_same<T: NdArrayElement + Scalar, Op: SimdCmpOp<T>>(
  function cmp (line 159) | fn cmp<'a, S: Simd, T: NdArrayElement + Scalar, Op: SimdCmpOp<T>>(
  function unsafe_alias_slice_mut (line 220) | fn unsafe_alias_slice_mut<'a, T>(slice: &mut [T]) -> &'a mut [T] {
  function try_cmp_scalar_simd (line 234) | pub fn try_cmp_scalar_simd<E: Element, T: NdArrayElement + Scalar, Op: S...
  function cmp_scalar_simd_inplace (line 260) | unsafe fn cmp_scalar_simd_inplace<T: NdArrayElement + Scalar, Op: SimdCm...
  function cmp_scalar_simd_owned (line 273) | fn cmp_scalar_simd_owned<T: NdArrayElement + Scalar, Op: SimdCmpOp<T>>(
  function cmp_scalar_slice (line 287) | fn cmp_scalar_slice<'a, S: Simd, T: NdArrayElement + Scalar, Op: SimdCmp...
  function cmp_scalar_slice_inplace (line 336) | unsafe fn cmp_scalar_slice_inplace<'a, S: Simd, T: NdArrayElement + Scal...

FILE: crates/burn-ndarray/src/ops/simd/conv.rs
  type Args (line 16) | type Args<E> = (SharedArray<E>, SharedArray<E>, Option<SharedArray<E>>);
  function try_conv2d_simd (line 19) | pub fn try_conv2d_simd<E: FloatNdArrayElement>(
  function cast (line 38) | fn cast<T, E>(tensor: SharedArray<T>) -> SharedArray<E> {
  function conv2d (line 47) | fn conv2d<E: VMulAdd + Element, T: Element>(
  constant REGISTER_BLOCK (line 145) | const REGISTER_BLOCK: usize = 8;
  function conv2d_launch (line 155) | unsafe fn conv2d_launch<
  function conv2d_remainder (line 256) | unsafe fn conv2d_remainder<S: Simd, E: VMulAdd>(

FILE: crates/burn-ndarray/src/ops/simd/maxpool.rs
  function is_accelerated_impl (line 13) | fn is_accelerated_impl<S: Simd, T: VOrd>(_x: PhantomData<T>) -> bool {
  function is_accelerated (line 17) | fn is_accelerated<T: VOrd>() -> bool {
  function try_max_pool2d_simd (line 44) | pub(crate) fn try_max_pool2d_simd<E: Element>(
  function cast (line 59) | fn cast<T, E>(tensor: SharedArray<T>) -> SharedArray<E> {
  constant BLOCK_REGISTERS (line 75) | const BLOCK_REGISTERS: usize = 8;
  function max_pool2d_nhwc (line 77) | pub(crate) fn max_pool2d_nhwc<E: Element + VOrd + MinMax>(
  function loop_blocked (line 165) | fn loop_blocked<'a, S: Simd, E: Element + VOrd + MinMax>(
  function loop_unblocked (line 279) | unsafe fn loop_unblocked<'a, S: Simd, E: Element + VOrd + MinMax>(
  function loop_scalar (line 352) | fn loop_scalar<E: Element + MinMax>(

FILE: crates/burn-ndarray/src/ops/simd/unary.rs
  type SimdUnop (line 15) | pub trait SimdUnop<T: Scalar, Out: Scalar> {
    method apply_vec (line 16) | fn apply_vec<S: Simd>(input: Vector<S, T>) -> Vector<S, Out>;
    method apply (line 17) | fn apply(input: T) -> Out;
    method is_accelerated (line 18) | fn is_accelerated<S: Simd>() -> bool;
  type RecipVec (line 21) | pub struct RecipVec;
    method apply_vec (line 24) | fn apply_vec<S: Simd>(input: Vector<S, f32>) -> Vector<S, f32> {
    method apply (line 28) | fn apply(input: f32) -> f32 {
    method is_accelerated (line 32) | fn is_accelerated<S: Simd>() -> bool {
  type VecAbs (line 37) | pub struct VecAbs;
    method apply_vec (line 40) | fn apply_vec<S: Simd>(input: Vector<S, T>) -> Vector<S, T> {
    method apply (line 44) | fn apply(input: T) -> T {
    method is_accelerated (line 48) | fn is_accelerated<S: Simd>() -> bool {
  type VecBitNot (line 53) | pub struct VecBitNot;
    method apply_vec (line 56) | fn apply_vec<S: Simd>(input: Vector<S, T>) -> Vector<S, T> {
    method apply (line 60) | fn apply(input: T) -> T {
    method is_accelerated (line 64) | fn is_accelerated<S: Simd>() -> bool {
  function is_accelerated (line 70) | fn is_accelerated<S: Simd, T: Scalar, Out: Scalar, Op: SimdUnop<T, Out>>(
  function try_unary_simd (line 76) | pub fn try_unary_simd<
  function unary_scalar_simd_inplace (line 109) | unsafe fn unary_scalar_simd_inplace<
  function unary_scalar_simd_owned (line 125) | fn unary_scalar_simd_owned<
  function unary_slice (line 141) | fn unary_slice<
  function unary_slice_inplace (line 193) | unsafe fn unary_slice_inplace<

FILE: crates/burn-ndarray/src/ops/tensor.rs
  function round_ties_even_wrapper (line 36) | fn round_ties_even_wrapper(x: f64) -> f64 {
  function round_ties_even_wrapper (line 42) | fn round_ties_even_wrapper(x: f64) -> f64 {
  function float_from_data (line 56) | fn float_from_data(data: TensorData, _device: &NdArrayDevice) -> FloatTe...
  function float_random (line 60) | fn float_random(
  function float_into_data (line 75) | async fn float_into_data(tensor: FloatTensor<Self>) -> Result<TensorData...
  function float_device (line 79) | fn float_device(_tensor: &FloatTensor<Self>) -> NdArrayDevice {
  function float_to_device (line 83) | fn float_to_device(tensor: FloatTensor<Self>, _device: &NdArrayDevice) -...
  function float_empty (line 87) | fn float_empty(
  function float_add (line 95) | fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_add_scalar (line 99) | fn float_add_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_sub (line 105) | fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_sub_scalar (line 109) | fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_mul (line 115) | fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_mul_scalar (line 119) | fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_div (line 125) | fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_div_scalar (line 129) | fn float_div_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_remainder (line 135) | fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Fl...
  function float_remainder_scalar (line 139) | fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatT...
  function float_matmul (line 145) | fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Float...
  function float_cross (line 149) | fn float_cross(
  function float_recip (line 157) | fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_swap_dims (line 163) | fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) ...
  function float_reshape (line 169) | fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor...
  function float_gather (line 175) | fn float_gather(
  function float_scatter_add (line 191) | fn float_scatter_add(
  function float_select (line 208) | fn float_select(
  function float_select_add (line 224) | fn float_select_add(
  function float_slice (line 241) | fn float_slice(tensor: FloatTensor<Self>, slices: &[burn_backend::Slice]...
  function float_slice_assign (line 245) | fn float_slice_assign(
  function float_mask_where (line 255) | fn float_mask_where(
  function float_mask_fill (line 265) | fn float_mask_fill(
  function float_equal (line 275) | fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> NdArra...
  function float_equal_elem (line 279) | fn float_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> NdArrayTensor {
  function float_greater (line 285) | fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> NdAr...
  function float_greater_elem (line 289) | fn float_greater_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> NdArrayTen...
  function float_greater_equal (line 295) | fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -...
  function float_greater_equal_elem (line 301) | fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> NdAr...
  function float_lower (line 307) | fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> NdArra...
  function float_lower_elem (line 311) | fn float_lower_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> NdArrayTensor {
  function float_lower_equal (line 317) | fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> ...
  function float_lower_equal_elem (line 323) | fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> NdArra...
  function float_detach (line 329) | fn float_detach(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_mean (line 333) | fn float_mean(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sum (line 340) | fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_mean_dim (line 347) | fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<...
  function float_cumsum (line 353) | fn float_cumsum(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_cumprod (line 359) | fn float_cumprod(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_cummin (line 365) | fn float_cummin(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_cummax (line 371) | fn float_cummax(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_sum_dim (line 377) | fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_argmax (line 383) | fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> NdArrayTensor {
  function float_argmin (line 390) | fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> NdArrayTensor {
  function float_exp (line 397) | fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_log (line 403) | fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_prod (line 409) | fn float_prod(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_prod_dim (line 416) | fn float_prod_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<...
  function float_max (line 422) | fn float_max(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_min (line 429) | fn float_min(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_log1p (line 436) | fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_powf_scalar_impl (line 442) | fn float_powf_scalar_impl(tensor: FloatTensor<Self>, value: Scalar) -> F...
  function float_sqrt (line 450) | fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_abs (line 456) | fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cos (line 462) | fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cosh (line 470) | fn float_cosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sin (line 478) | fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sinh (line 486) | fn float_sinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_tan (line 494) | fn float_tan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_tanh (line 502) | fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_acos (line 510) | fn float_acos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_acosh (line 518) | fn float_acosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asin (line 526) | fn float_asin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asinh (line 534) | fn float_asinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan (line 542) | fn float_atan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atanh (line 550) | fn float_atanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan2 (line 558) | fn float_atan2(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatT...
  function float_round (line 564) | fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_floor (line 572) | fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_ceil (line 580) | fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_trunc (line 588) | fn float_trunc(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_erf (line 596) | fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cat (line 604) | fn float_cat(tensors: Vec<FloatTensor<Self>>, dim: usize) -> FloatTensor...
  function float_clamp_min (line 608) | fn float_clamp_min(tensor: FloatTensor<Self>, min: Scalar) -> FloatTenso...
  function float_clamp_max (line 614) | fn float_clamp_max(tensor: FloatTensor<Self>, max: Scalar) -> FloatTenso...
  function float_clamp (line 620) | fn float_clamp(tensor: FloatTensor<Self>, min: Scalar, max: Scalar) -> F...
  function float_into_int (line 626) | fn float_into_int(tensor: FloatTensor<Self>) -> NdArrayTensor {
  function float_powf (line 632) | fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTe...
  function float_permute (line 638) | fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTens...
  function float_flip (line 644) | fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<...
  function float_sign (line 650) | fn float_sign(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_expand (line 656) | fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<...
  function float_cast (line 662) | fn float_cast(tensor: FloatTensor<Self>, dtype: FloatDType) -> FloatTens...
  function float_grid_sample_2d (line 668) | fn float_grid_sample_2d(
  function float_unfold (line 678) | fn float_unfold(

FILE: crates/burn-ndarray/src/rand.rs
  type NdArrayRng (line 10) | pub type NdArrayRng = StdRng;
  type NdArrayRng (line 12) | pub type NdArrayRng = SmallRng;
  function get_seeded_rng (line 22) | pub fn get_seeded_rng() -> NdArrayRng {
  function get_seeded_rng (line 32) | pub fn get_seeded_rng() -> NdArrayRng {

FILE: crates/burn-ndarray/src/sharing.rs
  type UnsafeSharedRef (line 4) | pub(crate) struct UnsafeSharedRef<'a, T> {
  function new (line 11) | pub fn new(data: &'a mut T) -> Self {
  function get (line 16) | pub unsafe fn get(&self) -> &'a mut T {

FILE: crates/burn-ndarray/src/storage.rs
  type NdArrayStorage (line 38) | pub enum NdArrayStorage<E: Element> {
  method clone (line 53) | fn clone(&self) -> Self {
  function from_borrowed (line 80) | pub fn from_borrowed(bytes: Bytes, shape: impl Into<Shape>) -> Result<Se...
  function from_owned (line 109) | pub fn from_owned(array: ArcArray<E, IxDyn>) -> Self {
  function is_unique (line 127) | pub fn is_unique(&self) -> bool {
  function view (line 138) | pub fn view(&self) -> ArrayView<'_, E, IxDyn> {
  function into_owned (line 158) | pub fn into_owned(self) -> ArcArray<E, IxDyn> {
  function into_shared (line 175) | pub fn into_shared(self) -> ArcArray<E, IxDyn> {
  function shape (line 180) | pub fn shape(&self) -> &[usize] {
  function ndim (line 189) | pub fn ndim(&self) -> usize {
  function len (line 195) | pub fn len(&self) -> usize {
  function is_empty (line 201) | pub fn is_empty(&self) -> bool {
  function is_borrowed (line 207) | pub fn is_borrowed(&self) -> bool {
  function is_owned (line 213) | pub fn is_owned(&self) -> bool {
  function ensure_owned (line 220) | pub fn ensure_owned(&mut self) -> &mut ArcArray<E, IxDyn> {
  function from (line 237) | fn from(array: ArcArray<E, IxDyn>) -> Self {
  function test_borrowed_is_not_unique (line 249) | fn test_borrowed_is_not_unique() {
  function test_owned_unique_when_single_ref (line 259) | fn test_owned_unique_when_single_ref() {
  function test_owned_not_unique_when_cloned (line 268) | fn test_owned_not_unique_when_cloned() {
  function test_view_zero_copy (line 277) | fn test_view_zero_copy() {
  function test_into_owned_copies_borrowed (line 288) | fn test_into_owned_copies_borrowed() {
  function test_from_borrowed_validates_alignment (line 299) | fn test_from_borrowed_validates_alignment() {
  function test_insufficient_size_returns_err (line 350) | fn test_insufficient_size_returns_err() {
  function test_zero_copy_native_allocation (line 370) | fn test_zero_copy_native_allocation() {
  function test_zero_copy_shared_bytes_pointer_identity (line 400) | fn test_zero_copy_shared_bytes_pointer_identity() {
  function test_clone_borrowed_stays_borrowed (line 437) | fn test_clone_borrowed_stays_borrowed() {
  function test_zero_copy_triggers_copy_on_mutation (line 472) | fn test_zero_copy_triggers_copy_on_mutation() {
  function test_borrowed_reports_not_unique (line 493) | fn test_borrowed_reports_not_unique() {

FILE: crates/burn-ndarray/src/tensor.rs
  type SharedArray (line 13) | pub type SharedArray<E> = ArcArray<E, IxDyn>;
  type NdArrayTensor (line 22) | pub enum NdArrayTensor {
    method bool (line 38) | pub(crate) fn bool(self) -> SharedArray<bool> {
    method is_borrowed (line 47) | pub fn is_borrowed(&self) -> bool {
    method into_data (line 385) | pub(crate) fn into_data(self) -> TensorData {
    method is_contiguous (line 419) | pub(crate) fn is_contiguous(&self) -> bool {
    method from_data (line 534) | pub fn from_data(data: TensorData) -> NdArrayTensor {
    method try_from_data_borrowed (line 556) | fn try_from_data_borrowed(data: TensorData) -> Result<NdArrayTensor, T...
    method from_data_owned (line 600) | fn from_data_owned(data: TensorData) -> NdArrayTensor {
  function cast_to_dtype (line 59) | pub(crate) fn cast_to_dtype<E1: Element>(array: SharedArray<E1>, dtype: ...
  method dtype (line 321) | fn dtype(&self) -> DType {
  method shape (line 337) | fn shape(&self) -> Shape {
  method rank (line 349) | fn rank(&self) -> usize {
  type ShapeOps (line 354) | pub(crate) trait ShapeOps {
    method num_dims (line 355) | fn num_dims(self) -> usize;
    method num_elements (line 356) | fn num_elements(self) -> usize;
    method dims (line 357) | fn dims<const N: usize>(self) -> [usize; N];
    method into_shape (line 358) | fn into_shape(self) -> Shape;
    method num_dims (line 362) | fn num_dims(self) -> usize {
    method num_elements (line 366) | fn num_elements(self) -> usize {
    method dims (line 370) | fn dims<const N: usize>(self) -> [usize; N] {
    method into_shape (line 374) | fn into_shape(self) -> Shape {
  type NdArrayQTensor (line 628) | pub struct NdArrayQTensor {
    method strategy (line 639) | pub fn strategy(&self) -> QuantizationStrategy {
  method scheme (line 685) | fn scheme(&self) -> &QuantScheme {
  method default_scheme (line 689) | fn default_scheme() -> QuantScheme {
  method dtype (line 695) | fn dtype(&self) -> DType {
  method shape (line 699) | fn shape(&self) -> Shape {
  method rank (line 703) | fn rank(&self) -> usize {
  function should_support_into_and_from_data_1d (line 722) | fn should_support_into_and_from_data_1d() {
  function should_support_into_and_from_data_2d (line 736) | fn should_support_into_and_from_data_2d() {
  function should_support_into_and_from_data_3d (line 750) | fn should_support_into_and_from_data_3d() {
  function should_support_into_and_from_data_4d (line 764) | fn should_support_into_and_from_data_4d() {
  function should_support_qtensor_strategy (line 778) | fn should_support_qtensor_strategy() {
  function zero_copy_creates_borrowed_storage_for_non_native (line 808) | fn zero_copy_creates_borrowed_storage_for_non_native() {
  function native_alloc_creates_owned_storage (line 843) | fn native_alloc_creates_owned_storage() {
  function zero_copy_data_integrity (line 867) | fn zero_copy_data_integrity() {
  function zero_copy_fallback_when_bytes_owned (line 890) | fn zero_copy_fallback_when_bytes_owned() {

FILE: crates/burn-nn/src/activation/activation_wrapper.rs
  type ActivationConfig (line 17) | pub enum ActivationConfig {
    method from (line 77) | fn from(config: PReluConfig) -> Self {
    method from (line 83) | fn from(config: LeakyReluConfig) -> Self {
    method from (line 89) | fn from(config: SwiGluConfig) -> Self {
    method from (line 95) | fn from(config: HardSigmoidConfig) -> Self {
    method from (line 101) | fn from(config: SoftplusConfig) -> Self {
    method from (line 107) | fn from(config: EluConfig) -> Self {
    method from (line 113) | fn from(config: CeluConfig) -> Self {
    method from (line 119) | fn from(config: ThresholdedReluConfig) -> Self {
    method from (line 125) | fn from(config: HardShrinkConfig) -> Self {
    method from (line 131) | fn from(config: SoftShrinkConfig) -> Self {
    method from (line 137) | fn from(config: ShrinkConfig) -> Self {
    method init (line 144) | pub fn init<B: Backend>(&self, device: &B::Device) -> Activation<B> {
  type Activation (line 175) | pub enum Activation<B: Backend> {
  function from (line 232) | fn from(layer: Gelu) -> Self {
  function from (line 238) | fn from(layer: PRelu<B>) -> Self {
  function from (line 244) | fn from(layer: Relu) -> Self {
  function from (line 250) | fn from(layer: LeakyRelu) -> Self {
  function from (line 256) | fn from(layer: SwiGlu<B>) -> Self {
  function from (line 262) | fn from(layer: Selu) -> Self {
  function from (line 268) | fn from(layer: Sigmoid) -> Self {
  function from (line 274) | fn from(layer: Tanh) -> Self {
  function from (line 280) | fn from(layer: HardSigmoid) -> Self {
  function from (line 286) | fn from(layer: HardSwish) -> Self {
  function from (line 292) | fn from(layer: Softplus) -> Self {
  function from (line 298) | fn from(layer: Softsign) -> Self {
  function from (line 304) | fn from(layer: Elu) -> Self {
  function from (line 310) | fn from(layer: Celu) -> Self {
  function from (line 316) | fn from(layer: ThresholdedRelu) -> Self {
  function from (line 322) | fn from(layer: HardShrink) -> Self {
  function from (line 328) | fn from(layer: SoftShrink) -> Self {
  function from (line 334) | fn from(layer: Shrink) -> Self {
  function forward (line 341) | pub fn forward<const D: usize>(&self, input: Tensor<B, D>) -> Tensor<B, ...
  function make_input (line 371) | fn make_input<B: Backend>(device: &B::Device) -> Tensor<B, 2> {
  function expect_tensor (line 375) | fn expect_tensor<B: Backend, const D: usize>(actual: Tensor<B, D>, expec...
  function check_stateless_config_output (line 379) | fn check_stateless_config_output<B: Backend, const D: usize>(
  function test_gelu (line 391) | fn test_gelu() {
  function test_gelu_approximate (line 401) | fn test_gelu_approximate() {
  function test_prelu (line 411) | fn test_prelu() {
  function test_relu (line 422) | fn test_relu() {
  function test_leaky_relu (line 432) | fn test_leaky_relu() {
  function test_swi_glu (line 443) | fn test_swi_glu() {
  function test_selu (line 472) | fn test_selu() {
  function test_sigmoid (line 482) | fn test_sigmoid() {
  function test_tanh (line 492) | fn test_tanh() {
  function test_hard_sigmoid (line 502) | fn test_hard_sigmoid() {
  function test_softsign (line 513) | fn test_softsign() {
  function test_elu (line 523) | fn test_elu() {
  function test_softplus (line 534) | fn test_softplus() {
  function test_celu (line 545) | fn test_celu() {
  function test_thresholded_relu (line 556) | fn test_thresholded_relu() {
  function test_hard_shrink (line 567) | fn test_hard_shrink() {
  function test_soft_shrink (line 578) | fn test_soft_shrink() {
  function test_shrink (line 589) | fn test_shrink() {

FILE: crates/burn-nn/src/activation/celu.rs
  type Celu (line 18) | pub struct Celu {
    method forward (line 58) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  type CeluConfig (line 25) | pub struct CeluConfig {
    method init (line 33) | pub fn init(&self) -> Celu {
  method custom_settings (line 39) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 45) | fn custom_content(&self, content: Content) -> Option<Content> {
  type FT (line 69) | type FT = FloatElem<TestBackend>;
  function test_celu_forward (line 72) | fn test_celu_forward() {
  function test_celu_with_alpha (line 87) | fn test_celu_with_alpha() {
  function display (line 100) | fn display() {

FILE: crates/burn-nn/src/activation/elu.rs
  type Elu (line 15) | pub struct Elu {
    method forward (line 53) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  type EluConfig (line 21) | pub struct EluConfig {
    method init (line 28) | pub fn init(&self) -> Elu {
  method custom_settings (line 34) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 40) | fn custom_content(&self, content: Content) -> Option<Content> {
  type FT (line 64) | type FT = FloatElem<TestBackend>;
  function test_elu_forward (line 67) | fn test_elu_forward() {
  function display (line 81) | fn display() {

FILE: crates/burn-nn/src/activation/gelu.rs
  type Gelu (line 14) | pub struct Gelu {
    method new (line 21) | pub fn new() -> Self {
    method new_approximate (line 26) | pub fn new_approximate() -> Self {
    method forward (line 36) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  type FT (line 52) | type FT = FloatElem<TestBackend>;
  function display (line 55) | fn display() {
  function forward_approximate (line 62) | fn forward_approximate() {

FILE: crates/burn-nn/src/activation/glu.rs
  type GLU (line 11) | pub struct GLU {
    method new (line 20) | pub fn new(dim: usize) -> Self {
    method forward (line 36) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  function display (line 46) | fn display() {

FILE: crates/burn-nn/src/activation/hard_shrink.rs
  type HardShrink (line 18) | pub struct HardShrink {
    method forward (line 60) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  type HardShrinkConfig (line 25) | pub struct HardShrinkConfig {
    method init (line 33) | pub fn init(&self) -> HardShrink {
  method custom_settings (line 41) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 47) | fn custom_content(&self, content: Content) -> Option<Content> {
  function test_hard_shrink_forward (line 72) | fn test_hard_shrink_forward() {
  function test_hard_shrink_with_lambda (line 83) | fn test_hard_shrink_with_lambda() {
  function display (line 94) | fn display() {

FILE: crates/burn-nn/src/activation/hard_sigmoid.rs
  type HardSigmoid (line 15) | pub struct HardSigmoid {
    method forward (line 64) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  type HardSigmoidConfig (line 23) | pub struct HardSigmoidConfig {
    method init (line 33) | pub fn init(&self) -> HardSigmoid {
  method custom_settings (line 42) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 48) | fn custom_content(&self, content: Content) -> Option<Content> {
  type FT (line 75) | type FT = FloatElem<TestBackend>;
  function test_hard_sigmoid_forward (line 78) | fn test_hard_sigmoid_forward() {
  function display (line 90) | fn display() {

FILE: crates/burn-nn/src/activation/hard_swish.rs
  type HardSwish (line 10) | pub struct HardSwish;
    method new (line 14) | pub fn new() -> Self {
    method forward (line 25) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  type FT (line 36) | type FT = FloatElem<TestBackend>;
  function test_hard_swish_forward (line 39) | fn test_hard_swish_forward() {
  function display (line 54) | fn display() {

FILE: crates/burn-nn/src/activation/leaky_relu.rs
  type LeakyRelu (line 15) | pub struct LeakyRelu {
    method forward (line 57) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  type LeakyReluConfig (line 21) | pub struct LeakyReluConfig {
    method init (line 28) | pub fn init(&self) -> LeakyRelu {
  method custom_settings (line 36) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 42) | fn custom_content(&self, content: Content) -> Option<Content> {
  type FT (line 68) | type FT = FloatElem<TestBackend>;
  function test_leaky_relu_forward (line 71) | fn test_leaky_relu_forward() {
  function test_leaky_relu_forward_multi_dim (line 81) | fn test_leaky_relu_forward_multi_dim() {
  function display (line 117) | fn display() {

FILE: crates/burn-nn/src/activation/prelu.rs
  type PRelu (line 11) | pub struct PRelu<B: Backend> {
  method custom_settings (line 21) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 27) | fn custom_content(&self, content: Content) -> Option<Content> {
  type PReluConfig (line 39) | pub struct PReluConfig {
    method init (line 50) | pub fn init<B: Backend>(&self, device: &B::Device) -> PRelu<B> {
  function forward (line 68) | pub fn forward<const D: usize>(&self, input: Tensor<B, D>) -> Tensor<B, ...
  function display (line 79) | fn display() {

FILE: crates/burn-nn/src/activation/relu.rs
  type Relu (line 11) | pub struct Relu;
    method new (line 15) | pub fn new() -> Self {
    method forward (line 24) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  function display (line 34) | fn display() {

FILE: crates/burn-nn/src/activation/selu.rs
  type Selu (line 10) | pub struct Selu;
    method new (line 14) | pub fn new() -> Self {
    method forward (line 23) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  function display (line 33) | fn display() {

FILE: crates/burn-nn/src/activation/shrink.rs
  type Shrink (line 18) | pub struct Shrink {
    method forward (line 70) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  type ShrinkConfig (line 28) | pub struct ShrinkConfig {
    method init (line 39) | pub fn init(&self) -> Shrink {
  method custom_settings (line 48) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 54) | fn custom_content(&self, content: Content) -> Option<Content> {
  function test_shrink_forward (line 82) | fn test_shrink_forward() {
  function test_shrink_with_lambda_and_bias (line 93) | fn test_shrink_with_lambda_and_bias() {
  function display (line 107) | fn display() {

FILE: crates/burn-nn/src/activation/sigmoid.rs
  type Sigmoid (line 10) | pub struct Sigmoid;
    method new (line 14) | pub fn new() -> Self {
    method forward (line 23) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  function display (line 33) | fn display() {

FILE: crates/burn-nn/src/activation/soft_shrink.rs
  type SoftShrink (line 18) | pub struct SoftShrink {
    method forward (line 60) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  type SoftShrinkConfig (line 25) | pub struct SoftShrinkConfig {
    method init (line 33) | pub fn init(&self) -> SoftShrink {
  method custom_settings (line 41) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 47) | fn custom_content(&self, content: Content) -> Option<Content> {
  function test_soft_shrink_forward (line 72) | fn test_soft_shrink_forward() {
  function test_soft_shrink_with_lambda (line 83) | fn test_soft_shrink_with_lambda() {
  function display (line 94) | fn display() {

FILE: crates/burn-nn/src/activation/softplus.rs
  type Softplus (line 18) | pub struct Softplus {
    method forward (line 58) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  type SoftplusConfig (line 25) | pub struct SoftplusConfig {
    method init (line 33) | pub fn init(&self) -> Softplus {
  method custom_settings (line 39) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 45) | fn custom_content(&self, content: Content) -> Option<Content> {
  type FT (line 70) | type FT = FloatElem<TestBackend>;
  function test_softplus_forward (line 73) | fn test_softplus_forward() {
  function test_softplus_with_beta (line 88) | fn test_softplus_with_beta() {
  function display (line 101) | fn display() {

FILE: crates/burn-nn/src/activation/softsign.rs
  type Softsign (line 10) | pub struct Softsign;
    method new (line 14) | pub fn new() -> Self {
    method forward (line 23) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  function display (line 33) | fn display() {

FILE: crates/burn-nn/src/activation/swiglu.rs
  type SwiGluConfig (line 12) | pub struct SwiGluConfig {
    method init (line 66) | pub fn init<B: Backend>(&self, device: &B::Device) -> SwiGlu<B> {
  type SwiGlu (line 38) | pub struct SwiGlu<B: Backend> {
  method custom_settings (line 48) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 54) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 89) | pub fn forward<const D: usize>(&self, input: Tensor<B, D>) -> Tensor<B, ...
  type FT (line 101) | type FT = FloatElem<TestBackend>;
  function test_swiglu_forward_no_bias (line 104) | fn test_swiglu_forward_no_bias() {
  function test_swiglu_forward_with_bias (line 123) | fn test_swiglu_forward_with_bias() {
  function display (line 144) | fn display() {

FILE: crates/burn-nn/src/activation/tanh.rs
  type Tanh (line 10) | pub struct Tanh;
    method new (line 14) | pub fn new() -> Self {
    method forward (line 23) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  function display (line 33) | fn display() {

FILE: crates/burn-nn/src/activation/thresholded_relu.rs
  type ThresholdedRelu (line 15) | pub struct ThresholdedRelu {
    method forward (line 55) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  type ThresholdedReluConfig (line 22) | pub struct ThresholdedReluConfig {
    method init (line 30) | pub fn init(&self) -> ThresholdedRelu {
  method custom_settings (line 36) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 42) | fn custom_content(&self, content: Content) -> Option<Content> {
  function test_thresholded_relu_forward (line 67) | fn test_thresholded_relu_forward() {
  function display (line 78) | fn display() {

FILE: crates/burn-nn/src/lib.rs
  type TestBackend (line 38) | pub type TestBackend = burn_ndarray::NdArray<f32>;
  type TestBackend (line 42) | pub type TestBackend = burn_tch::LibTorch<f32>;
  type TestBackend (line 46) | pub type TestBackend = burn_wgpu::Wgpu;
  type TestBackend (line 50) | pub type TestBackend = burn_cuda::Cuda;
  type TestBackend (line 54) | pub type TestBackend = burn_rocm::Rocm;
  type TestAutodiffBackend (line 58) | pub type TestAutodiffBackend = burn_autodiff::Autodiff<TestBackend>;

FILE: crates/burn-nn/src/loss/binary_cross_entropy.rs
  type BinaryCrossEntropyLossConfig (line 11) | pub struct BinaryCrossEntropyLossConfig {
    method init (line 30) | pub fn init<B: Backend>(&self, device: &B::Device) -> BinaryCrossEntro...
    method assertions (line 42) | fn assertions(&self) {
  type BinaryCrossEntropyLoss (line 63) | pub struct BinaryCrossEntropyLoss<B: Backend> {
  method custom_settings (line 73) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 79) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 100) | pub fn forward<const D: usize>(
  function assertions (line 142) | fn assertions<const D: usize>(&self, logits: &Tensor<B, D>, targets: &Te...
  type FT (line 169) | type FT = FloatElem<TestBackend>;
  function test_binary_cross_entropy_preds_all_correct (line 172) | fn test_binary_cross_entropy_preds_all_correct() {
  function test_binary_cross_entropy_preds_all_incorrect (line 188) | fn test_binary_cross_entropy_preds_all_incorrect() {
  function test_binary_cross_entropy (line 204) | fn test_binary_cross_entropy() {
  function test_binary_cross_entropy_with_logits (line 229) | fn test_binary_cross_entropy_with_logits() {
  function test_binary_cross_entropy_with_weights (line 247) | fn test_binary_cross_entropy_with_weights() {
  function test_binary_cross_entropy_with_smoothing (line 275) | fn test_binary_cross_entropy_with_smoothing() {
  function test_binary_cross_entropy_multilabel (line 302) | fn test_binary_cross_entropy_multilabel() {
  function test_binary_cross_entropy_multilabel_with_weights (line 332) | fn test_binary_cross_entropy_multilabel_with_weights() {
  function test_binary_cross_entropy_multilabel_with_smoothing (line 363) | fn test_binary_cross_entropy_multilabel_with_smoothing() {
  function multilabel_weights_should_match_target (line 395) | fn multilabel_weights_should_match_target() {
  function display (line 422) | fn display() {

FILE: crates/burn-nn/src/loss/cosine_embedding.rs
  type CosineEmbeddingLossConfig (line 15) | pub struct CosineEmbeddingLossConfig {
    method init (line 27) | pub fn init(&self) -> CosineEmbeddingLoss {
  type CosineEmbeddingLoss (line 41) | pub struct CosineEmbeddingLoss {
    method new (line 72) | pub fn new() -> Self {
    method forward (line 87) | pub fn forward<B: Backend>(
    method forward_no_reduction (line 112) | pub fn forward_no_reduction<B: Backend>(
    method assertions (line 141) | fn assertions<B: Backend>(
  method default (line 50) | fn default() -> Self {
  method custom_settings (line 56) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 62) | fn custom_content(&self, content: Content) -> Option<Content> {
  type FT (line 174) | type FT = FloatElem<TestBackend>;
  function cosine_embedding_loss_positive_target (line 177) | fn cosine_embedding_loss_positive_target() {
  function cosine_embedding_loss_negative_target (line 219) | fn cosine_embedding_loss_negative_target() {
  function cosine_embedding_loss_mixed_targets (line 275) | fn cosine_embedding_loss_mixed_targets() {
  function display (line 308) | fn display() {

FILE: crates/burn-nn/src/loss/cross_entropy.rs
  type CrossEntropyLossConfig (line 14) | pub struct CrossEntropyLossConfig {
    method init (line 43) | pub fn init<B: Backend>(&self, device: &B::Device) -> CrossEntropyLoss...
    method assertions (line 56) | fn assertions(&self) {
  type CrossEntropyLoss (line 77) | pub struct CrossEntropyLoss<B: Backend> {
  method custom_settings (line 89) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 95) | fn custom_content(&self, content: Content) -> Option<Content> {
  function new (line 113) | pub fn new(pad_index: Option<usize>, device: &B::Device) -> Self {
  function forward (line 125) | pub fn forward(&self, logits: Tensor<B, 2>, targets: Tensor<B, 1, Int>) ...
  function forward_smoothed (line 133) | fn forward_smoothed(
  function forward_default (line 167) | fn forward_default(&self, logits: Tensor<B, 2>, targets: Tensor<B, 1, In...
  function compute_smoothed_targets (line 188) | fn compute_smoothed_targets(
  function padding_mask (line 204) | fn padding_mask(&self, targets: &Tensor<B, 1, Int>) -> Option<Tensor<B, ...
  function apply_mask_1d (line 217) | fn apply_mask_1d(mut tensor: Tensor<B, 1>, mask: Option<Tensor<B, 1, Boo...
  function apply_mask_2d (line 225) | fn apply_mask_2d(mut tensor: Tensor<B, 2>, mask: Option<Tensor<B, 1, Boo...
  function assertions (line 234) | fn assertions(logits: Tensor<B, 2>, targets: Tensor<B, 1, Int>) {
  type FT (line 250) | type FT = FloatElem<TestBackend>;
  function test_cross_entropy_loss_with_weights (line 303) | fn test_cross_entropy_loss_with_weights() {
  function test_label_smoothing_with_weights_and_alpha_zero (line 324) | fn test_label_smoothing_with_weights_and_alpha_zero() {
  function test_cross_entropy_loss (line 343) | fn test_cross_entropy_loss() {
  function test_label_smoothing_alpha_equal_zero (line 357) | fn test_label_smoothing_alpha_equal_zero() {
  function test_cross_entropy_loss_with_pad_token (line 374) | fn test_cross_entropy_loss_with_pad_token() {
  function test_label_smoothing_with_zero_alpha_and_pad_token (line 390) | fn test_label_smoothing_with_zero_alpha_and_pad_token() {
  function test_label_smoothing_target_conversion (line 410) | fn test_label_smoothing_target_conversion() {
  function test_label_smoothing (line 429) | fn test_label_smoothing() {
  function display (line 455) | fn display() {

FILE: crates/burn-nn/src/loss/ctc.rs
  type CTCLossConfig (line 14) | pub struct CTCLossConfig {
    method init (line 25) | pub fn init(&self) -> CTCLoss {
  type CTCLoss (line 81) | pub struct CTCLoss {
    method forward (line 110) | pub fn forward<B: Backend>(
    method forward_with_reduction (line 226) | pub fn forward_with_reduction<B: Backend>(
    method assertions (line 249) | fn assertions<B: Backend>(
    method insert_blanks (line 282) | fn insert_blanks<B: Backend>(
    method initialize_log_alpha (line 299) | fn initialize_log_alpha<B: Backend>(
    method right_shift_2d_tensor (line 328) | fn right_shift_2d_tensor<B: Backend, K>(
    method create_l_prime_mask (line 355) | fn create_l_prime_mask<B: Backend>(
    method create_s_mask (line 382) | fn create_s_mask<B: Backend>(
    method log_sum_exp (line 402) | fn log_sum_exp<const D: usize, B: Backend>(
    method create_combined_s_t_mask (line 452) | fn create_combined_s_t_mask<B: Backend>(
    method compute_log_alpha_t_s (line 470) | fn compute_log_alpha_t_s<B: Backend>(
  type TestBackend (line 513) | type TestBackend = NdArray<f32>;
  function assert_approx_equal (line 515) | fn assert_approx_equal(actual: &[f32], expected: &[f32], tol: f32) {
  function test_insert_blanks_single_sample (line 540) | fn test_insert_blanks_single_sample() {
  function test_insert_blanks_batch (line 551) | fn test_insert_blanks_batch() {
  function test_insert_blanks_custom_blank (line 562) | fn test_insert_blanks_custom_blank() {
  function test_ctc_loss_panics_invalid_blank_index (line 579) | fn test_ctc_loss_panics_invalid_blank_index() {
  function test_ctc_loss_panics_mismatched_batch_size (line 594) | fn test_ctc_loss_panics_mismatched_batch_size() {
  function test_ctc_loss_panics_input_lengths_mismatch (line 610) | fn test_ctc_loss_panics_input_lengths_mismatch() {
  function test_ctc_loss_panics_target_lengths_mismatch (line 627) | fn test_ctc_loss_panics_target_lengths_mismatch() {
  function test_ctc_loss_repeated_labels_minimum_input_length (line 647) | fn test_ctc_loss_repeated_labels_minimum_input_length() {
  function test_ctc_loss_custom_blank_uniform (line 668) | fn test_ctc_loss_custom_blank_uniform() {
  function test_ctc_loss_zero_infinity_produces_inf_when_disabled (line 694) | fn test_ctc_loss_zero_infinity_produces_inf_when_disabled() {
  function test_ctc_loss_zero_infinity_masks_inf_when_enabled (line 715) | fn test_ctc_loss_zero_infinity_masks_inf_when_enabled() {
  function test_ctc_loss_zero_infinity_does_not_affect_finite_loss (line 731) | fn test_ctc_loss_zero_infinity_does_not_affect_finite_loss() {
  type InnerBackend (line 756) | type InnerBackend = NdArray<f32>;
  type TestBackend (line 757) | type TestBackend = Autodiff<InnerBackend>;
  function assert_approx_equal (line 759) | fn assert_approx_equal(actual: &[f32], expected: &[f32], tol: f32) {
  function generate_logits (line 780) | fn generate_logits(
  function run_comparison (line 811) | fn run_comparison(
  function test_ctc_loss_uniform_input_lengths (line 860) | fn test_ctc_loss_uniform_input_lengths() {
  function test_ctc_loss_repeated_labels (line 944) | fn test_ctc_loss_repeated_labels() {
  function test_ctc_loss_long_sequence (line 1165) | fn test_ctc_loss_long_sequence() {
  function test_ctc_loss_mixed_input_lengths (line 1349) | fn test_ctc_loss_mixed_input_lengths() {
  function test_ctc_loss_sum_reduction (line 1553) | fn test_ctc_loss_sum_reduction() {
  function test_ctc_loss_mean_reduction (line 1643) | fn test_ctc_loss_mean_reduction() {

FILE: crates/burn-nn/src/loss/huber.rs
  type HuberLossConfig (line 12) | pub struct HuberLossConfig {
    method init (line 19) | pub fn init(&self) -> HuberLoss {
    method assertions (line 27) | fn assertions(&self) {
  type HuberLoss (line 53) | pub struct HuberLoss {
    method forward (line 86) | pub fn forward<const D: usize, B: Backend>(
    method forward_no_reduction (line 106) | pub fn forward_no_reduction<const D: usize, B: Backend>(
    method forward_residuals (line 120) | pub fn forward_residuals<const D: usize, B: Backend>(
  method custom_settings (line 61) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 67) | fn custom_content(&self, content: Content) -> Option<Content> {
  type TestTensor (line 146) | type TestTensor<const D: usize> = Tensor<TestBackend, D>;
  type FT (line 148) | type FT = FloatElem<TestBackend>;
  function test_huber_loss (line 151) | fn test_huber_loss() {
  function test_huber_ad_loss (line 183) | fn test_huber_ad_loss() {
  function display (line 206) | fn display() {

FILE: crates/burn-nn/src/loss/kldiv.rs
  type KLDivLossConfig (line 11) | pub struct KLDivLossConfig {
    method init (line 19) | pub fn init(&self) -> KLDivLoss {
  type KLDivLoss (line 41) | pub struct KLDivLoss {
    method forward (line 68) | pub fn forward<const D: usize, B: Backend>(
    method forward_no_reduction (line 85) | pub fn forward_no_reduction<const D: usize, B: Backend>(
  method custom_settings (line 47) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 53) | fn custom_content(&self, content: Content) -> Option<Content> {
  type TestTensor (line 106) | type TestTensor<const D: usize> = Tensor<TestBackend, D>;
  type FT (line 108) | type FT = FloatElem<TestBackend>;
  function test_kl_div_loss (line 111) | fn test_kl_div_loss() {
  function test_kl_div_loss_log_target (line 144) | fn test_kl_div_loss_log_target() {
  function test_kl_div_ad_loss (line 173) | fn test_kl_div_ad_loss() {
  function display (line 194) | fn display() {

FILE: crates/burn-nn/src/loss/lp_loss.rs
  type LpLossConfig (line 24) | pub struct LpLossConfig {
    method init (line 41) | pub fn init(&self) -> LpLoss {
    method l1 (line 50) | pub fn l1() -> LpLoss {
    method l2 (line 58) | pub fn l2() -> LpLoss {
    method assertions (line 62) | fn assertions(&self) {
  type LpLoss (line 114) | pub struct LpLoss {
    method forward (line 140) | pub fn forward<const D: usize, B: Backend>(
    method forward_no_reduction (line 172) | pub fn forward_no_reduction<const D: usize, B: Backend>(
    method forward_reduce_dims (line 219) | pub fn forward_reduce_dims<const D: usize, B: Backend>(
  type FT (line 242) | type FT = FloatElem<TestBackend>;
  function test_lp_loss_l1_constructor (line 245) | fn test_lp_loss_l1_constructor() {
  function test_lp_loss_l2_constructor (line 253) | fn test_lp_loss_l2_constructor() {
  function test_lp_loss_l1 (line 261) | fn test_lp_loss_l1() {
  function test_lp_loss_l2 (line 290) | fn test_lp_loss_l2() {
  function test_lp_loss_p_half (line 319) | fn test_lp_loss_p_half() {
  function test_lp_loss_p3 (line 350) | fn test_lp_loss_p3() {
  function test_lp_loss_zero_error (line 381) | fn test_lp_loss_zero_error() {
  function test_lp_loss_negative_errors (line 403) | fn test_lp_loss_negative_errors() {
  function test_lp_loss_3d_tensor (line 424) | fn test_lp_loss_3d_tensor() {
  function test_lp_loss_negative_p_panics (line 450) | fn test_lp_loss_negative_p_panics() {
  function test_lp_loss_zero_p_panics (line 456) | fn test_lp_loss_zero_p_panics() {
  function test_lp_loss_fractional_p (line 461) | fn test_lp_loss_fractional_p() {
  function test_forward_reduce_dims_single_dim (line 478) | fn test_forward_reduce_dims_single_dim() {
  function test_forward_reduce_dims_first_dim (line 508) | fn test_forward_reduce_dims_first_dim() {
  function test_forward_reduce_dims_multiple_dims (line 532) | fn test_forward_reduce_dims_multiple_dims() {
  function test_forward_reduce_dims_all_dims (line 556) | fn test_forward_reduce_dims_all_dims() {
  function test_forward_reduce_dims_image_batch (line 579) | fn test_forward_reduce_dims_image_batch() {
  function test_forward_reduce_dims_with_p1 (line 610) | fn test_forward_reduce_dims_with_p1() {
  function test_forward_reduce_dims_empty_dims (line 634) | fn test_forward_reduce_dims_empty_dims() {
  function test_forward_reduce_dims_zero_error (line 657) | fn test_forward_reduce_dims_zero_error() {

FILE: crates/burn-nn/src/loss/mse.rs
  type MseLoss (line 10) | pub struct MseLoss;
    method new (line 20) | pub fn new() -> Self {
    method forward (line 30) | pub fn forward<const D: usize, B: Backend>(
    method forward_no_reduction (line 45) | pub fn forward_no_reduction<const D: usize, B: Backend>(
  method default (line 13) | fn default() -> Self {
  function test_mse_loss (line 61) | fn test_mse_loss() {
  function display (line 89) | fn display() {

FILE: crates/burn-nn/src/loss/poisson.rs
  type PoissonNllLossConfig (line 19) | pub struct PoissonNllLossConfig {
    method init (line 53) | pub fn init(&self) -> PoissonNllLoss {
    method assertions (line 66) | fn assertions(&self) {
  type PoissonNllLoss (line 89) | pub struct PoissonNllLoss {
    method forward (line 132) | pub fn forward<const D: usize, B: Backend>(
    method forward_no_reduction (line 161) | pub fn forward_no_reduction<const D: usize, B: Backend>(
    method assertions (line 189) | fn assertions<const D: usize, B: Backend>(
  method custom_settings (line 99) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 105) | fn custom_content(&self, content: Content) -> Option<Content> {
  type TestTensor (line 230) | type TestTensor<const D: usize> = Tensor<TestBackend, D>;
  type FT (line 232) | type FT = FloatElem<TestBackend>;
  function test_poisson_nll_loss (line 235) | fn test_poisson_nll_loss() {
  function test_poisson_nll_loss_no_log_input (line 266) | fn test_poisson_nll_loss_no_log_input() {
  function test_poisson_nll_loss_full (line 286) | fn test_poisson_nll_loss_full() {
  function test_poisson_nll_loss_gradients (line 318) | fn test_poisson_nll_loss_gradients() {
  function test_negative_eps (line 355) | fn test_negative_eps() {
  function test_targets_with_negative_values (line 361) | fn test_targets_with_negative_values() {
  function test_shape_tensors (line 377) | fn test_shape_tensors() {
  function test_exp_predictions_non_negative (line 393) | fn test_exp_predictions_non_negative() {
  function display (line 408) | fn display() {

FILE: crates/burn-nn/src/loss/pretrained/gram_matrix/gram_matrix_loss.rs
  type GramMatrixLossConfig (line 32) | pub struct GramMatrixLossConfig {
    method init (line 64) | pub fn init<B: Backend>(&self, device: &B::Device) -> GramMatrixLoss<B> {
    method assertions (line 76) | fn assertions(&self) {
  type GramMatrixLoss (line 114) | pub struct GramMatrixLoss<B: Backend> {
  function forward (line 163) | pub fn forward(
  function forward_no_reduction (line 213) | pub fn forward_no_reduction(
  function preprocess_input (line 278) | fn preprocess_input(&self, tensor: Tensor<B, 4>) -> Tensor<B, 4> {
  function test_gram_matrix_loss_config_invalid_length (line 303) | fn test_gram_matrix_loss_config_invalid_length() {
  function test_gram_matrix_loss_config_negative_weights (line 310) | fn test_gram_matrix_loss_config_negative_weights() {
  function test_gram_matrix_loss_config_valid_weights (line 316) | fn test_gram_matrix_loss_config_valid_weights() {
  function test_gram_matrix_loss_1_channel_panic (line 329) | fn test_gram_matrix_loss_1_channel_panic() {
  function test_gram_matrix_loss_4_channel_panic (line 346) | fn test_gram_matrix_loss_4_channel_panic() {
  function test_gram_matrix_loss_zero_for_identical_inputs (line 362) | fn test_gram_matrix_loss_zero_for_identical_inputs() {
  function test_gram_matrix_loss_greater_than_zero_for_different_inputs (line 386) | fn test_gram_matrix_loss_greater_than_zero_for_different_inputs() {
  function test_gram_matrix_loss_forward_no_reduction_shape (line 406) | fn test_gram_matrix_loss_forward_no_reduction_shape() {
  function test_gram_matrix_loss_reduction_sum_vs_mean (line 426) | fn test_gram_matrix_loss_reduction_sum_vs_mean() {
  function test_gram_matrix_loss_with_avg_pool (line 457) | fn test_gram_matrix_loss_with_avg_pool() {
  function test_gram_matrix_loss_autodiff (line 479) | fn test_gram_matrix_loss_autodiff() {
  function test_gram_matrix_loss_pretrained_weights_identical_inputs (line 515) | fn test_gram_matrix_loss_pretrained_weights_identical_inputs() {
  function test_gram_matrix_loss_pretrained_weights_different_inputs (line 536) | fn test_gram_matrix_loss_pretrained_weights_different_inputs() {

FILE: crates/burn-nn/src/loss/pretrained/gram_matrix/vgg19.rs
  type Vgg19 (line 24) | pub struct Vgg19<B: Backend> {
  function new (line 58) | pub fn new(use_avg_pool: bool, device: &B::Device) -> Self {
  function forward (line 106) | pub fn forward(&self, x: Tensor<B, 4>) -> Vec<Tensor<B, 3>> {

FILE: crates/burn-nn/src/loss/pretrained/gram_matrix/weights.rs
  constant VGG19_URL (line 11) | const VGG19_URL: &str = "https://download.pytorch.org/models/vgg19-dcbb9...
  function get_cache_dir (line 17) | fn get_cache_dir() -> PathBuf {
  function download_weights_if_not_saved (line 35) | fn download_weights_if_not_saved(cache_path: &PathBuf) {
  function load_vgg19_weights (line 69) | pub fn load_vgg19_weights<B: Backend>(mut vgg19: Vgg19<B>) -> Vgg19<B> {

FILE: crates/burn-nn/src/loss/reduction.rs
  type Reduction (line 7) | pub enum Reduction {

FILE: crates/burn-nn/src/loss/rnnt.rs
  type RNNTLossConfig (line 10) | pub struct RNNTLossConfig {
    method init (line 22) | pub fn init(&self) -> RNNTLoss {
  type RNNTLoss (line 45) | pub struct RNNTLoss {
    method forward (line 57) | pub fn forward<B: Backend>(
    method forward_with_reduction (line 100) | pub fn forward_with_reduction<B: Backend>(
    method extract_log_probs (line 118) | fn extract_log_probs<B: Backend>(
    method init_alpha (line 149) | fn init_alpha<B: Backend>(
    method create_u_mask (line 170) | fn create_u_mask<B: Backend>(
    method step_alpha (line 190) | fn step_alpha<B: Backend>(
    method gather_loss (line 228) | fn gather_loss<B: Backend>(
    method check_inputs (line 252) | fn check_inputs<B: Backend>(
    method log_sum_exp (line 298) | fn log_sum_exp<const D: usize, B: Backend>(
  type B (line 326) | type B = NdArray<f32>;
  constant NUM_LABELS (line 327) | const NUM_LABELS: usize = 2;
  function config_defaults (line 330) | fn config_defaults() {
  function panics_on_invalid_blank (line 338) | fn panics_on_invalid_blank() {
  function panics_on_batch_mismatch (line 351) | fn panics_on_batch_mismatch() {
  function panics_on_logit_lengths_mismatch (line 364) | fn panics_on_logit_lengths_mismatch() {
  function panics_on_target_lengths_mismatch (line 377) | fn panics_on_target_lengths_mismatch() {
  function single_token_uniform_probs (line 389) | fn single_token_uniform_probs() {
  function empty_target (line 424) | fn empty_target() {
  function logits_equivalence (line 452) | fn logits_equivalence() {
  type B (line 503) | type B = Autodiff<NdArray<f32>>;
  function tol (line 504) | fn tol() -> Tolerance<f32> {
  function make_logits (line 510) | fn make_logits(bs: usize, t: usize, u: usize, v: usize, dev: &NdArrayDev...
  function check_vocab_grad_sums (line 528) | fn check_vocab_grad_sums(grad: &[f32], bs: usize, t: usize, up1: usize, ...
  function grad_at (line 542) | fn grad_at(
  function assert_grad (line 556) | fn assert_grad(
  function basic_b1 (line 571) | fn basic_b1() {
  function batched_b2 (line 603) | fn batched_b2() {
  function variable_lengths_b3 (line 639) | fn variable_lengths_b3() {
  function sum_reduction (line 734) | fn sum_reduction() {
  function mean_reduction (line 765) | fn mean_reduction() {

FILE: crates/burn-nn/src/loss/smooth_l1.rs
  type SmoothL1LossConfig (line 25) | pub struct SmoothL1LossConfig {
    method init (line 38) | pub fn init(&self) -> SmoothL1Loss {
    method assertions (line 43) | fn assertions(&self) {
  type SmoothL1Loss (line 97) | pub struct SmoothL1Loss {
    method forward (line 121) | pub fn forward<const D: usize, B: Backend>(
    method forward_with_reduction (line 158) | pub fn forward_with_reduction<const D: usize, B: Backend>(
    method forward_reduce_dims (line 200) | pub fn forward_reduce_dims<const D: usize, B: Backend>(
  type FT (line 224) | type FT = FloatElem<TestBackend>;
  function test_smooth_l1_config_default_beta (line 231) | fn test_smooth_l1_config_default_beta() {
  function test_smooth_l1_config_custom_beta (line 237) | fn test_smooth_l1_config_custom_beta() {
  function test_smooth_l1_config_beta_zero_panics (line 244) | fn test_smooth_l1_config_beta_zero_panics() {
  function test_smooth_l1_config_beta_negative_panics (line 250) | fn test_smooth_l1_config_beta_negative_panics() {
  function test_smooth_l1_forward_l2_region (line 259) | fn test_smooth_l1_forward_l2_region() {
  function test_smooth_l1_forward_l1_region (line 278) | fn test_smooth_l1_forward_l1_region() {
  function test_smooth_l1_forward_zero_error (line 298) | fn test_smooth_l1_forward_zero_error() {
  function test_smooth_l1_forward_negative_errors (line 312) | fn test_smooth_l1_forward_negative_errors() {
  function test_smooth_l1_forward_mixed_regions (line 330) | fn test_smooth_l1_forward_mixed_regions() {
  function test_smooth_l1_custom_beta_values (line 351) | fn test_smooth_l1_custom_beta_values() {
  function test_smooth_l1_reduction_mean (line 372) | fn test_smooth_l1_reduction_mean() {
  function test_smooth_l1_reduction_sum (line 389) | fn test_smooth_l1_reduction_sum() {
  function test_smooth_l1_reduction_auto_equals_mean (line 406) | fn test_smooth_l1_reduction_auto_equals_mean() {
  function test_smooth_l1_forward_reduce_dims_single_dim (line 425) | fn test_smooth_l1_forward_reduce_dims_single_dim() {
  function test_smooth_l1_forward_reduce_dims_image_batch (line 455) | fn test_smooth_l1_forward_reduce_dims_image_batch() {
  function test_smooth_l1_forward_reduce_dims_unsorted (line 481) | fn test_smooth_l1_forward_reduce_dims_unsorted() {
  function test_smooth_l1_forward_reduce_dims_empty_dims (line 502) | fn test_smooth_l1_forward_reduce_dims_empty_dims() {

FILE: crates/burn-nn/src/modules/attention/cross_attention.rs
  type CrossAttentionConfig (line 31) | pub struct CrossAttentionConfig {
    method init (line 115) | pub fn init<B: Backend>(&self, device: &B::Device) -> CrossAttention<B> {
  type CrossAttention (line 64) | pub struct CrossAttention<B: Backend> {
  type CrossAttentionCache (line 82) | pub struct CrossAttentionCache<B: Backend> {
  function new (line 91) | pub fn new() -> Self {
  method default (line 100) | fn default() -> Self {
  function forward (line 162) | pub fn forward(
  function forward_cache (line 244) | pub fn forward_cache(
  function repeat_kv (line 325) | fn repeat_kv(&self, x: Tensor<B, 4>, n_rep: usize) -> Tensor<B, 4> {
  function test_cross_attention_mha_shapes (line 340) | fn test_cross_attention_mha_shapes() {
  function test_cross_attention_gqa_shapes (line 384) | fn test_cross_attention_gqa_shapes() {
  function test_cross_attention_mqa_shapes (line 429) | fn test_cross_attention_mqa_shapes() {
  function test_cross_attention_mask (line 473) | fn test_cross_attention_mask() {
  function test_gqa_panic_if_n_heads_not_divisible_by_n_heads_kv (line 543) | fn test_gqa_panic_if_n_heads_not_divisible_by_n_heads_kv() {
  function test_cross_attention_cache (line 559) | fn test_cross_attention_cache() {

FILE: crates/burn-nn/src/modules/attention/mask.rs
  function generate_autoregressive_mask (line 12) | pub fn generate_autoregressive_mask<B: Backend>(
  type GeneratePaddingMask (line 22) | pub struct GeneratePaddingMask<B: Backend> {
  type SeqLengthOption (line 32) | pub enum SeqLengthOption {
    method from (line 42) | fn from(val: Option<usize>) -> Self {
  function generate_padding_mask (line 62) | pub fn generate_padding_mask<B: Backend>(
  function test_generate_autoregressive_mask (line 117) | fn test_generate_autoregressive_mask() {
  function test_generate_padding_mask (line 140) | fn test_generate_padding_mask() {

FILE: crates/burn-nn/src/modules/attention/mha.rs
  type MultiHeadAttentionConfig (line 17) | pub struct MultiHeadAttentionConfig {
    method init (line 116) | pub fn init<B: Backend>(&self, device: &B::Device) -> MultiHeadAttenti...
  type MultiHeadAttention (line 57) | pub struct MultiHeadAttention<B: Backend> {
  method custom_settings (line 83) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 89) | fn custom_content(&self, content: Content) -> Option<Content> {
  type MhaInput (line 103) | pub struct MhaInput<B: Backend> {
  function self_attn (line 145) | pub fn self_attn(tensor: Tensor<B, 3>) -> Self {
  function new (line 156) | pub fn new(query: Tensor<B, 3>, key: Tensor<B, 3>, value: Tensor<B, 3>) ...
  function mask_pad (line 167) | pub fn mask_pad(mut self, mask_pad: Tensor<B, 2, Bool>) -> Self {
  function mask_attn (line 173) | pub fn mask_attn(mut self, mask_attn: Tensor<B, 3, Bool>) -> Self {
  type MhaOutput (line 181) | pub struct MhaOutput<B: Backend> {
  function forward (line 199) | pub fn forward(&self, input: MhaInput<B>) -> MhaOutput<B> {
  function forward_cache (line 226) | pub fn forward_cache(&self, input: MhaInput<B>, cache: &mut MhaCache<B>)...
  function attn_scores (line 252) | fn attn_scores(&self, query: Tensor<B, 4>, key: Tensor<B, 4>) -> Tensor<...
  function attn_weights (line 260) | fn attn_weights(
  function attention_linear (line 291) | fn attention_linear(&self, x: Tensor<B, 3>, linear: &Linear<B>) -> Tenso...
  type MhaCache (line 303) | pub struct MhaCache<B: Backend> {
  type MhaLinearCache (line 310) | enum MhaLinearCache<B: Backend, const D: usize> {
  function autoregressive (line 317) | pub fn autoregressive() -> Self {
  function autoregressive_cross_attention (line 328) | pub fn autoregressive_cross_attention() -> Self {
  function forward (line 339) | pub fn forward<F: Fn(Tensor<B, 3>) -> Tensor<B, D>>(
  function test_self_attention_shapes (line 364) | fn test_self_attention_shapes() {
  function test_generic_mha_shapes (line 389) | fn test_generic_mha_shapes() {
  function test_self_attention_mask_pad (line 427) | fn test_self_attention_mask_pad() {
  function test_autoregressive_mask_should_have_same_output_as_autoregressive_decoding (line 481) | fn test_autoregressive_mask_should_have_same_output_as_autoregressive_de...
  function display (line 521) | fn display() {

FILE: crates/burn-nn/src/modules/cache/autoregressive.rs
  function forward_autoregressive (line 9) | pub(crate) fn forward_autoregressive<F>(
  function forward_full (line 37) | pub(crate) fn forward_full<F>(&mut self, tensor: Tensor<B, 3>, func: F) ...

FILE: crates/burn-nn/src/modules/cache/base.rs
  type CacheState (line 6) | pub(crate) enum CacheState<T> {
  type TensorCache (line 12) | pub struct TensorCache<B: Backend, const D: usize> {
  function empty (line 22) | pub fn empty() -> Self {

FILE: crates/burn-nn/src/modules/conv/checks.rs
  function checks_channels_div_groups (line 1) | pub(crate) fn checks_channels_div_groups(channels_in: usize, channels_ou...
  function check_same_padding_support (line 16) | pub(crate) fn check_same_padding_support(kernel_size: &[usize]) {

FILE: crates/burn-nn/src/modules/conv/conv1d.rs
  type Conv1dConfig (line 14) | pub struct Conv1dConfig {
    method init (line 100) | pub fn init<B: Backend>(&self, device: &B::Device) -> Conv1d<B> {
  type Conv1d (line 51) | pub struct Conv1d<B: Backend> {
  method custom_settings (line 69) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 75) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 144) | pub fn forward(&self, input: Tensor<B, 3>) -> Tensor<B, 3> {
  type FT (line 172) | type FT = FloatElem<TestBackend>;
  function initializer_default (line 179) | fn initializer_default() {
  function initializer_zeros (line 192) | fn initializer_zeros() {
  function same_with_even_kernel_uses_asymmetric_padding (line 206) | fn same_with_even_kernel_uses_asymmetric_padding() {
  function display (line 223) | fn display() {
  function input_channels_mismatch (line 235) | fn input_channels_mismatch() {
  function asymmetric_padding_forward (line 244) | fn asymmetric_padding_forward() {
  function symmetric_explicit_padding_forward (line 263) | fn symmetric_explicit_padding_forward() {

FILE: crates/burn-nn/src/modules/conv/conv2d.rs
  type Conv2dConfig (line 18) | pub struct Conv2dConfig {
    method init (line 72) | pub fn init<B: Backend>(&self, device: &B::Device) -> Conv2d<B> {
  type Conv2d (line 53) | pub struct Conv2d<B: Backend> {
  method custom_settings (line 113) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 119) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 163) | pub fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
  type FT (line 199) | type FT = FloatElem<TestBackend>;
  function initializer_default (line 202) | fn initializer_default() {
  function initializer_zeros (line 215) | fn initializer_zeros() {
  function initializer_fan_out (line 230) | fn initializer_fan_out() {
  function initializer_fan_with_groups_is_valid (line 246) | fn initializer_fan_with_groups_is_valid() {
  function channels_with_groups_is_invalid (line 265) | fn channels_with_groups_is_invalid() {
  function same_with_even_kernel_uses_asymmetric_padding (line 272) | fn same_with_even_kernel_uses_asymmetric_padding() {
  function display (line 289) | fn display() {
  function input_channels_mismatch (line 301) | fn input_channels_mismatch() {
  function asymmetric_padding_forward (line 310) | fn asymmetric_padding_forward() {
  function symmetric_explicit_padding_forward (line 329) | fn symmetric_explicit_padding_forward() {

FILE: crates/burn-nn/src/modules/conv/conv3d.rs
  type Conv3dConfig (line 18) | pub struct Conv3dConfig {
    method init (line 69) | pub fn init<B: Backend>(&self, device: &B::Device) -> Conv3d<B> {
  type Conv3d (line 50) | pub struct Conv3d<B: Backend> {
  method custom_settings (line 114) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 120) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 153) | pub fn forward(&self, input: Tensor<B, 5>) -> Tensor<B, 5> {
  type FT (line 174) | type FT = FloatElem<TestBackend>;
  function initializer_default (line 181) | fn initializer_default() {
  function initializer_zeros (line 197) | fn initializer_zeros() {
  function initializer_fan_out (line 213) | fn initializer_fan_out() {
  function initializer_fan_with_groups_is_valid (line 228) | fn initializer_fan_with_groups_is_valid() {
  function same_with_even_kernel_is_invalid (line 247) | fn same_with_even_kernel_is_invalid() {
  function display (line 254) | fn display() {
  function input_channels_mismatch (line 266) | fn input_channels_mismatch() {

FILE: crates/burn-nn/src/modules/conv/conv_transpose1d.rs
  type ConvTranspose1dConfig (line 21) | pub struct ConvTranspose1dConfig {
    method init (line 97) | pub fn init<B: Backend>(&self, device: &B::Device) -> ConvTranspose1d<...
  type ConvTranspose1d (line 54) | pub struct ConvTranspose1d<B: Backend> {
  method custom_settings (line 76) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 82) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 142) | pub fn forward(&self, input: Tensor<B, 3>) -> Tensor<B, 3> {
  type FT (line 166) | type FT = FloatElem<TestBackend>;
  function initializer_default (line 169) | fn initializer_default() {
  function initializer_zeros (line 182) | fn initializer_zeros() {
  function display (line 197) | fn display() {
  function input_channels_mismatch (line 209) | fn input_channels_mismatch() {

FILE: crates/burn-nn/src/modules/conv/conv_transpose2d.rs
  type ConvTranspose2dConfig (line 21) | pub struct ConvTranspose2dConfig {
    method init (line 97) | pub fn init<B: Backend>(&self, device: &B::Device) -> ConvTranspose2d<...
  type ConvTranspose2d (line 54) | pub struct ConvTranspose2d<B: Backend> {
  method custom_settings (line 76) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 82) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 143) | pub fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
  type FT (line 165) | type FT = FloatElem<TestBackend>;
  function initializer_default (line 168) | fn initializer_default() {
  function initializer_zeros (line 181) | fn initializer_zeros() {
  function display (line 197) | fn display() {
  function input_channels_mismatch (line 209) | fn input_channels_mismatch() {

FILE: crates/burn-nn/src/modules/conv/conv_transpose3d.rs
  type ConvTranspose3dConfig (line 21) | pub struct ConvTranspose3dConfig {
    method init (line 97) | pub fn init<B: Backend>(&self, device: &B::Device) -> ConvTranspose3d<...
  type ConvTranspose3d (line 54) | pub struct ConvTranspose3d<B: Backend> {
  method custom_settings (line 76) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 82) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 144) | pub fn forward(&self, input: Tensor<B, 5>) -> Tensor<B, 5> {
  type FT (line 163) | type FT = FloatElem<TestBackend>;
  function initializer_default (line 170) | fn initializer_default() {
  function initializer_zeros (line 186) | fn initializer_zeros() {
  function display (line 202) | fn display() {
  function input_channels_mismatch (line 214) | fn input_channels_mismatch() {

FILE: crates/burn-nn/src/modules/conv/deform_conv2d.rs
  type DeformConv2dConfig (line 18) | pub struct DeformConv2dConfig {
    method init (line 78) | pub fn init<B: Backend>(&self, device: &B::Device) -> DeformConv2d<B> {
  type DeformConv2d (line 57) | pub struct DeformConv2d<B: Backend> {
  method custom_settings (line 123) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 129) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 157) | pub fn forward(
  type FT (line 187) | type FT = FloatElem<TestBackend>;
  function initializer_default (line 194) | fn initializer_default() {
  function initializer_zeros (line 207) | fn initializer_zeros() {
  function initializer_fan_out (line 222) | fn initializer_fan_out() {
  function initializer_fan_with_groups_is_valid (line 238) | fn initializer_fan_with_groups_is_valid() {
  function channels_with_groups_is_invalid (line 257) | fn channels_with_groups_is_invalid() {
  function same_with_even_kernel_is_invalid (line 265) | fn same_with_even_kernel_is_invalid() {
  function display (line 272) | fn display() {
  function input_channels_mismatch (line 284) | fn input_channels_mismatch() {

FILE: crates/burn-nn/src/modules/dropout.rs
  type DropoutConfig (line 10) | pub struct DropoutConfig {
    method init (line 32) | pub fn init(&self) -> Dropout {
  type Dropout (line 25) | pub struct Dropout {
    method forward (line 52) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  method custom_settings (line 66) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 72) | fn custom_content(&self, content: Content) -> Option<Content> {
  function with_ad_backend_should_mark_input (line 90) | fn with_ad_backend_should_mark_input() {
  function without_ad_backend_should_not_change_input (line 101) | fn without_ad_backend_should_not_change_input() {
  function display (line 111) | fn display() {
  function dropout_prob_invalid (line 120) | fn dropout_prob_invalid() {

FILE: crates/burn-nn/src/modules/embedding.rs
  type EmbeddingConfig (line 16) | pub struct EmbeddingConfig {
    method init (line 55) | pub fn init<B: Backend>(&self, device: &B::Device) -> Embedding<B> {
  type Embedding (line 31) | pub struct Embedding<B: Backend> {
  method custom_settings (line 38) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 44) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 73) | pub fn forward(&self, input: Tensor<B, 2, Int>) -> Tensor<B, 3> {
  type FT (line 84) | type FT = FloatElem<TestBackend>;
  function initializer_zeros (line 87) | fn initializer_zeros() {
  function display (line 102) | fn display() {

FILE: crates/burn-nn/src/modules/interpolate/interpolate1d.rs
  type Interpolate1dConfig (line 20) | pub struct Interpolate1dConfig {
    method init (line 72) | pub fn init(self) -> Interpolate1d {
  type Interpolate1d (line 56) | pub struct Interpolate1d {
    method forward (line 104) | pub fn forward<B: Backend>(&self, input: Tensor<B, 3>) -> Tensor<B, 3> {
  function calculate_output_size (line 138) | fn calculate_output_size(
  method custom_settings (line 165) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 171) | fn custom_content(&self, content: Content) -> Option<Content> {
  function test_calculate_output_size (line 188) | fn test_calculate_output_size() {
  function test_panic (line 206) | fn test_panic() {
  function test_large_scale_factor (line 213) | fn test_large_scale_factor() {
  function test_module (line 219) | fn test_module() {
  function display (line 248) | fn display() {

FILE: crates/burn-nn/src/modules/interpolate/interpolate2d.rs
  type Interpolate2dConfig (line 20) | pub struct Interpolate2dConfig {
    method init (line 73) | pub fn init(self) -> Interpolate2d {
  type Interpolate2d (line 57) | pub struct Interpolate2d {
    method forward (line 104) | pub fn forward<B: Backend>(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
  function calculate_output_size (line 131) | fn calculate_output_size(
  method custom_settings (line 164) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 170) | fn custom_content(&self, content: Content) -> Option<Content> {
  function test_calculate_output_size (line 187) | fn test_calculate_output_size() {
  function test_missing_params (line 205) | fn test_missing_params() {
  function test_infinite_height (line 211) | fn test_infinite_height() {
  function test_infinite_width (line 217) | fn test_infinite_width() {
  function test_module (line 222) | fn test_module() {
  function display (line 251) | fn display() {

FILE: crates/burn-nn/src/modules/interpolate/mod.rs
  type InterpolateMode (line 16) | pub enum InterpolateMode {
  method from (line 49) | fn from(mode: InterpolateMode) -> Self {

FILE: crates/burn-nn/src/modules/linear.rs
  type LinearConfig (line 11) | pub struct LinearConfig {
    method init (line 58) | pub fn init<B: Backend>(&self, device: &B::Device) -> Linear<B> {
  type LinearLayout (line 33) | pub enum LinearLayout {
  type Linear (line 47) | pub struct Linear<B: Backend> {
  function forward (line 125) | pub fn forward<const D: usize>(&self, input: Tensor<B, D>) -> Tensor<B, ...
  method custom_settings (line 135) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 141) | fn custom_content(&self, content: Content) -> Option<Content> {
  type FT (line 160) | type FT = FloatElem<TestBackend>;
  function initializer_default (line 163) | fn initializer_default() {
  function initializer_zeros (line 182) | fn initializer_zeros() {
  function test_linear_forward_no_bias (line 197) | fn test_linear_forward_no_bias() {
  function test_linear_forward_with_bias (line 215) | fn test_linear_forward_with_bias() {
  function test_linear_1d (line 233) | fn test_linear_1d() {
  function display (line 253) | fn display() {
  function layout (line 264) | fn layout() {
  function col_row_same_result (line 316) | fn col_row_same_result() {

FILE: crates/burn-nn/src/modules/noise.rs
  type GaussianNoiseConfig (line 10) | pub struct GaussianNoiseConfig {
    method init (line 31) | pub fn init(&self) -> GaussianNoise {
  type GaussianNoise (line 24) | pub struct GaussianNoise {
    method forward (line 51) | pub fn forward<B: Backend, const D: usize>(&self, input: Tensor<B, D>)...
  method custom_settings (line 66) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 72) | fn custom_content(&self, content: Content) -> Option<Content> {
  function with_ad_backend_should_mark_input (line 90) | fn with_ad_backend_should_mark_input() {
  function without_ad_backend_should_not_change_input (line 101) | fn without_ad_backend_should_not_change_input() {
  function negative_std_should_panic (line 112) | fn negative_std_should_panic() {
  function display (line 117) | fn display() {

FILE: crates/burn-nn/src/modules/norm/batch.rs
  type BatchNormConfig (line 15) | pub struct BatchNormConfig {
    method init (line 61) | pub fn init<B: Backend>(&self, device: &B::Device) -> BatchNorm<B> {
  type BatchNorm (line 44) | pub struct BatchNorm<B: Backend> {
  function forward (line 92) | pub fn forward<const D: usize>(&self, input: Tensor<B, D>) -> Tensor<B, ...
  function forward_inference (line 109) | fn forward_inference<const D: usize>(&self, input: Tensor<B, D>) -> Tens...
  function forward_train (line 121) | fn forward_train<const D: usize>(&self, input: Tensor<B, D>) -> Tensor<B...
  function forward_shared (line 173) | fn forward_shared<const D: usize>(
  method custom_settings (line 195) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 201) | fn custom_content(&self, content: Content) -> Option<Content> {
  type FT (line 220) | type FT = FloatElem<TestAutodiffBackend>;
  function batch_norm_forward_train (line 223) | fn batch_norm_forward_train() {
  function batch_norm_forward_inference (line 235) | fn batch_norm_forward_inference() {
  function expected_valid (line 248) | fn expected_valid() -> TensorData {
  function expected_train (line 255) | fn expected_train() -> TensorData {
  function input_tensor (line 270) | fn input_tensor<B: Backend>(device: &B::Device) -> Tensor<B, 3> {
  function batch_norm_forward_train_inference (line 281) | fn batch_norm_forward_train_inference() {
  type FT (line 309) | type FT = FloatElem<TestAutodiffBackend>;
  function batch_norm_forward_train (line 312) | fn batch_norm_forward_train() {
  function batch_norm_forward_inference (line 336) | fn batch_norm_forward_inference() {
  function batch_norm_running_mean (line 362) | fn batch_norm_running_mean() {
  function batch_norm_running_var (line 378) | fn batch_norm_running_var() {
  function batch_norm_running_mean_inner_module (line 394) | fn batch_norm_running_mean_inner_module() {
  function batch_norm_grads (line 410) | fn batch_norm_grads() {
  function input_tensor (line 457) | fn input_tensor<B: Backend>(device: &B::Device) -> Tensor<B, 4> {
  function display (line 476) | fn display() {

FILE: crates/burn-nn/src/modules/norm/group.rs
  type GroupNormConfig (line 13) | pub struct GroupNormConfig {
    method init (line 75) | pub fn init<B: Backend>(&self, device: &B::Device) -> GroupNorm<B> {
  type GroupNorm (line 41) | pub struct GroupNorm<B: Backend> {
  method custom_settings (line 57) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 63) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 111) | pub fn forward<const D: usize>(&self, input: Tensor<B, D>) -> Tensor<B, ...
  function group_norm (line 144) | pub(crate) fn group_norm<B: Backend, const D: usize>(
  type FT (line 196) | type FT = FloatElem<TestBackend>;
  function group_norm_forward_affine_false (line 199) | fn group_norm_forward_affine_false() {
  function group_norm_forward_affine_true (line 256) | fn group_norm_forward_affine_true() {
  function display (line 327) | fn display() {

FILE: crates/burn-nn/src/modules/norm/instance.rs
  type InstanceNormConfig (line 12) | pub struct InstanceNormConfig {
    method init (line 61) | pub fn init<B: Backend>(&self, device: &B::Device) -> InstanceNorm<B> {
  type InstanceNorm (line 30) | pub struct InstanceNorm<B: Backend> {
  method custom_settings (line 44) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 50) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 90) | pub fn forward<const D: usize>(&self, input: Tensor<B, D>) -> Tensor<B, ...
  type FT (line 108) | type FT = FloatElem<TestBackend>;
  function instance_norm_forward_affine_false (line 111) | fn instance_norm_forward_affine_false() {
  function instance_norm_forward_affine_true (line 165) | fn instance_norm_forward_affine_true() {
  function display (line 219) | fn display() {

FILE: crates/burn-nn/src/modules/norm/layer.rs
  type LayerNormConfig (line 15) | pub struct LayerNormConfig {
    method init (line 50) | pub fn init<B: Backend>(&self, device: &B::Device) -> LayerNorm<B> {
  type LayerNorm (line 39) | pub struct LayerNorm<B: Backend> {
  function forward (line 75) | pub fn forward<const D: usize>(&self, input: Tensor<B, D>) -> Tensor<B, ...
  method custom_settings (line 90) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 96) | fn custom_content(&self, content: Content) -> Option<Content> {
  type FT (line 112) | type FT = FloatElem<TestBackend>;
  function layer_norm_forward (line 121) | fn layer_norm_forward() {
  function layer_norm_forward_large_epsilon (line 142) | fn layer_norm_forward_large_epsilon() {
  function layer_norm_backward (line 166) | fn layer_norm_backward() {
  function display (line 212) | fn display() {
  function display_no_bias (line 223) | fn display_no_bias() {

FILE: crates/burn-nn/src/modules/norm/normalization_wrapper.rs
  type NormalizationConfig (line 21) | pub enum NormalizationConfig {
    method from (line 39) | fn from(config: BatchNormConfig) -> Self {
    method from (line 45) | fn from(config: GroupNormConfig) -> Self {
    method from (line 51) | fn from(config: InstanceNormConfig) -> Self {
    method from (line 57) | fn from(config: LayerNormConfig) -> Self {
    method from (line 63) | fn from(config: RmsNormConfig) -> Self {
    method init (line 70) | pub fn init<B: Backend>(&self, device: &B::Device) -> Normalization<B> {
    method with_num_features (line 81) | pub fn with_num_features(self, num_features: usize) -> Self {
    method num_features (line 112) | pub fn num_features(&self) -> usize {
  type Normalization (line 135) | pub enum Normalization<B: Backend> {
  function from (line 153) | fn from(layer: BatchNorm<B>) -> Self {
  function from (line 159) | fn from(layer: GroupNorm<B>) -> Self {
  function from (line 165) | fn from(layer: InstanceNorm<B>) -> Self {
  function from (line 171) | fn from(layer: LayerNorm<B>) -> Self {
  function from (line 177) | fn from(layer: RmsNorm<B>) -> Self {
  function forward (line 188) | pub fn forward<const D: usize>(&self, input: Tensor<B, D>) -> Tensor<B, ...
  function num_features (line 199) | pub fn num_features(&self) -> usize {
  type FT (line 216) | type FT = FloatElem<TestAutodiffBackend>;
  function test_match_feature_size (line 219) | fn test_match_feature_size() {
  function test_batch_norm (line 247) | fn test_batch_norm() {
  function test_group_norm (line 270) | fn test_group_norm() {
  function test_instance_norm (line 295) | fn test_instance_norm() {
  function test_layer_norm (line 320) | fn test_layer_norm() {
  function test_rms_norm (line 345) | fn test_rms_norm() {

FILE: crates/burn-nn/src/modules/norm/rms.rs
  type RmsNormConfig (line 15) | pub struct RmsNormConfig {
    method init (line 29) | pub fn init<B: Backend>(&self, device: &B::Device) -> RmsNorm<B> {
  type RmsNorm (line 55) | pub struct RmsNorm<B: Backend> {
  function forward (line 71) | pub fn forward<const D: usize>(&self, x: Tensor<B, D>) -> Tensor<B, D> {
  method custom_settings (line 80) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 86) | fn custom_content(&self, content: Content) -> Option<Content> {
  type FT (line 102) | type FT = FloatElem<TestBackend>;
  function rms_norm_forward (line 105) | fn rms_norm_forward() {
  function display (line 125) | fn display() {

FILE: crates/burn-nn/src/modules/pool/adaptive_avg_pool1d.rs
  type AdaptiveAvgPool1dConfig (line 13) | pub struct AdaptiveAvgPool1dConfig {
    method init (line 42) | pub fn init(&self) -> AdaptiveAvgPool1d {
  type AdaptiveAvgPool1d (line 23) | pub struct AdaptiveAvgPool1d {
    method forward (line 58) | pub fn forward<B: Backend>(&self, input: Tensor<B, 3>) -> Tensor<B, 3> {
  method custom_settings (line 29) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 35) | fn custom_content(&self, content: Content) -> Option<Content> {
  function display (line 68) | fn display() {

FILE: crates/burn-nn/src/modules/pool/adaptive_avg_pool2d.rs
  type AdaptiveAvgPool2dConfig (line 13) | pub struct AdaptiveAvgPool2dConfig {
    method init (line 44) | pub fn init(&self) -> AdaptiveAvgPool2d {
  type AdaptiveAvgPool2d (line 23) | pub struct AdaptiveAvgPool2d {
    method forward (line 60) | pub fn forward<B: Backend>(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
  method custom_settings (line 29) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 35) | fn custom_content(&self, content: Content) -> Option<Content> {
  function display (line 70) | fn display() {

FILE: crates/burn-nn/src/modules/pool/avg_pool1d.rs
  type AvgPool1dConfig (line 15) | pub struct AvgPool1dConfig {
    method init (line 81) | pub fn init(&self) -> AvgPool1d {
  type AvgPool1d (line 48) | pub struct AvgPool1d {
    method forward (line 101) | pub fn forward<B: Backend>(&self, input: Tensor<B, 3>) -> Tensor<B, 3> {
  method custom_settings (line 62) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 68) | fn custom_content(&self, content: Content) -> Option<Content> {
  function same_with_even_kernel_uses_asymmetric_padding (line 146) | fn same_with_even_kernel_uses_asymmetric_padding() {
  function display (line 162) | fn display() {
  function default_strides_match_kernel_size (line 175) | fn default_strides_match_kernel_size(#[case] kernel_size: usize) {
  function asymmetric_padding_forward (line 186) | fn asymmetric_padding_forward() {
  function symmetric_explicit_padding_forward (line 204) | fn symmetric_explicit_padding_forward() {

FILE: crates/burn-nn/src/modules/pool/avg_pool2d.rs
  type AvgPool2dConfig (line 15) | pub struct AvgPool2dConfig {
    method init (line 81) | pub fn init(&self) -> AvgPool2d {
  type AvgPool2d (line 48) | pub struct AvgPool2d {
    method forward (line 101) | pub fn forward<B: Backend>(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
  method custom_settings (line 62) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 68) | fn custom_content(&self, content: Content) -> Option<Content> {
  function same_with_even_kernel_uses_asymmetric_padding (line 148) | fn same_with_even_kernel_uses_asymmetric_padding() {
  function display (line 164) | fn display() {
  function default_strides_match_kernel_size (line 178) | fn default_strides_match_kernel_size(#[case] kernel_size: [usize; 2]) {
  function asymmetric_padding_forward (line 189) | fn asymmetric_padding_forward() {
  function symmetric_explicit_padding_forward (line 207) | fn symmetric_explicit_padding_forward() {

FILE: crates/burn-nn/src/modules/pool/max_pool1d.rs
  type MaxPool1dConfig (line 15) | pub struct MaxPool1dConfig {
    method init (line 73) | pub fn init(&self) -> MaxPool1d {
  type MaxPool1d (line 40) | pub struct MaxPool1d {
    method forward (line 93) | pub fn forward<B: Backend>(&self, input: Tensor<B, 3>) -> Tensor<B, 3> {
  method custom_settings (line 54) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 60) | fn custom_content(&self, content: Content) -> Option<Content> {
  function same_with_even_kernel_uses_asymmetric_padding (line 139) | fn same_with_even_kernel_uses_asymmetric_padding() {
  function display (line 155) | fn display() {
  function default_strides_match_kernel_size (line 169) | fn default_strides_match_kernel_size(#[case] kernel_size: usize) {
  function asymmetric_padding_forward (line 180) | fn asymmetric_padding_forward() {
  function symmetric_explicit_padding_forward (line 198) | fn symmetric_explicit_padding_forward() {

FILE: crates/burn-nn/src/modules/pool/max_pool2d.rs
  type MaxPool2dConfig (line 15) | pub struct MaxPool2dConfig {
    method init (line 73) | pub fn init(&self) -> MaxPool2d {
  type MaxPool2d (line 40) | pub struct MaxPool2d {
    method forward (line 93) | pub fn forward<B: Backend>(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
  method custom_settings (line 54) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 60) | fn custom_content(&self, content: Content) -> Option<Content> {
  function same_with_even_kernel_uses_asymmetric_padding (line 144) | fn same_with_even_kernel_uses_asymmetric_padding() {
  function display (line 160) | fn display() {
  function default_strides_match_kernel_size (line 174) | fn default_strides_match_kernel_size(#[case] kernel_size: [usize; 2]) {
  function asymmetric_padding_forward (line 185) | fn asymmetric_padding_forward() {
  function symmetric_explicit_padding_forward (line 203) | fn symmetric_explicit_padding_forward() {

FILE: crates/burn-nn/src/modules/pos_encoding.rs
  type PositionalEncodingConfig (line 17) | pub struct PositionalEncodingConfig {
    method init (line 74) | pub fn init<B: Backend>(&self, device: &B::Device) -> PositionalEncodi...
  type PositionalEncoding (line 46) | pub struct PositionalEncoding<B: Backend> {
  method custom_settings (line 56) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 62) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 104) | pub fn forward(&self, input: Tensor<B, 3>) -> Tensor<B, 3> {
  function generate_sinusoids (line 141) | pub fn generate_sinusoids<B: Backend>(
  type FT (line 191) | type FT = FloatElem<TestBackend>;
  function test_module (line 194) | fn test_module() {
  function test_generate_sinusoids (line 234) | fn test_generate_sinusoids() {
  function d_model_input_should_match (line 263) | fn d_model_input_should_match() {
  function input_length_should_be_less_than_max_len (line 273) | fn input_length_should_be_less_than_max_len() {
  function display (line 282) | fn display() {

FILE: crates/burn-nn/src/modules/rnn/basic.rs
  type RnnState (line 11) | pub struct RnnState<B: Backend, const D: usize> {
  function new (line 18) | pub fn new(hidden: Tensor<B, D>) -> Self {
  type RnnConfig (line 25) | pub struct RnnConfig {
    method init (line 94) | pub fn init<B: Backend>(&self, device: &B::Device) -> Rnn<B> {
  type Rnn (line 57) | pub struct Rnn<B: Backend> {
  method custom_settings (line 74) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 80) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 136) | pub fn forward(
  function forward_iter (line 180) | fn forward_iter<I: Iterator<Item = (Tensor<B, 3>, usize)>>(
  type BiRnnConfig (line 229) | pub struct BiRnnConfig {
    method init (line 287) | pub fn init<B: Backend>(&self, device: &B::Device) -> BiRnn<B> {
  type BiRnn (line 254) | pub struct BiRnn<B: Backend> {
  method custom_settings (line 267) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 273) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 322) | pub fn forward(
  type FT (line 399) | type FT = FloatElem<TestBackend>;
  function create_single_feature_gate_controller (line 404) | fn create_single_feature_gate_controller(
  function test_with_uniform_initializer (line 432) | fn test_with_uniform_initializer() {
  function test_forward_single_input_single_feature (line 452) | fn test_forward_single_input_single_feature() {
  function test_batched_forward_pass_batch_of_one (line 490) | fn test_batched_forward_pass_batch_of_one() {
  function test_batched_backward_pass (line 503) | fn test_batched_backward_pass() {
  function test_bidirectional (line 530) | fn test_bidirectional() {
  function display_rnn (line 653) | fn display_rnn() {
  function display_birnn (line 665) | fn display_birnn() {
  function test_rnn_clipping (line 677) | fn test_rnn_clipping() {
  function test_forward_reverse_sequence (line 702) | fn test_forward_reverse_sequence() {

FILE: crates/burn-nn/src/modules/rnn/gate_controller.rs
  type GateController (line 16) | pub struct GateController<B: Backend> {
  function new (line 25) | pub fn new(
  function gate_product (line 61) | pub fn gate_product(&self, input: Tensor<B, 2>, hidden: Tensor<B, 2>) ->...
  function create_with_weights (line 69) | pub fn create_with_weights(

FILE: crates/burn-nn/src/modules/rnn/gru.rs
  type GruConfig (line 14) | pub struct GruConfig {
    method init (line 101) | pub fn init<B: Backend>(&self, device: &B::Device) -> Gru<B> {
  type Gru (line 60) | pub struct Gru<B: Backend> {
  method custom_settings (line 80) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 86) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 150) | pub fn forward(
  function forward_iter (line 182) | pub(crate) fn forward_iter<I: Iterator<Item = (Tensor<B, 3>, usize)>>(
  function gate_product (line 251) | fn gate_product(
  type BiGruConfig (line 280) | pub struct BiGruConfig {
    method init (line 353) | pub fn init<B: Backend>(&self, device: &B::Device) -> BiGru<B> {
  type BiGru (line 314) | pub struct BiGru<B: Backend> {
  method custom_settings (line 327) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 333) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 388) | pub fn forward(
  type FT (line 462) | type FT = FloatElem<TestBackend>;
  function init_gru (line 464) | fn init_gru<B: Backend>(reset_after: bool, device: &B::Device) -> Gru<B> {
  function tests_forward_single_input_single_feature (line 533) | fn tests_forward_single_input_single_feature() {
  function tests_forward_seq_len_3 (line 568) | fn tests_forward_seq_len_3() {
  function test_batched_forward_pass (line 601) | fn test_batched_forward_pass() {
  function display (line 613) | fn display() {
  function test_bigru_batched_forward_pass (line 625) | fn test_bigru_batched_forward_pass() {
  function test_bigru_with_initial_state (line 640) | fn test_bigru_with_initial_state() {
  function test_bigru_seq_first (line 655) | fn test_bigru_seq_first() {
  function test_bigru_against_pytorch (line 674) | fn test_bigru_against_pytorch() {
  function bigru_display (line 843) | fn bigru_display() {
  function test_gru_custom_activations (line 855) | fn test_gru_custom_activations() {
  function test_bigru_custom_activations (line 872) | fn test_bigru_custom_activations() {
  function test_gru_clipping (line 889) | fn test_gru_clipping() {
  function test_bigru_clipping (line 915) | fn test_bigru_clipping() {
  function test_gru_against_pytorch (line 955) | fn test_gru_against_pytorch() {

FILE: crates/burn-nn/src/modules/rnn/lstm.rs
  type LstmState (line 11) | pub struct LstmState<B: Backend, const D: usize> {
  function new (line 20) | pub fn new(cell: Tensor<B, D>, hidden: Tensor<B, D>) -> Self {
  type LstmConfig (line 27) | pub struct LstmConfig {
    method init (line 124) | pub fn init<B: Backend>(&self, device: &B::Device) -> Lstm<B> {
  type Lstm (line 74) | pub struct Lstm<B: Backend> {
  method custom_settings (line 104) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 110) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 172) | pub fn forward(
  function forward_iter (line 216) | fn forward_iter<I: Iterator<Item = (Tensor<B, 3>, usize)>>(
  type BiLstmConfig (line 294) | pub struct BiLstmConfig {
    method init (line 370) | pub fn init<B: Backend>(&self, device: &B::Device) -> BiLstm<B> {
  type BiLstm (line 331) | pub struct BiLstm<B: Backend> {
  method custom_settings (line 344) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 350) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 408) | pub fn forward(
  type FT (line 500) | type FT = FloatElem<TestBackend>;
  function test_with_uniform_initializer (line 506) | fn test_with_uniform_initializer() {
  function test_forward_single_input_single_feature (line 532) | fn test_forward_single_input_single_feature() {
  function test_batched_forward_pass (line 630) | fn test_batched_forward_pass() {
  function test_batched_forward_pass_batch_of_one (line 644) | fn test_batched_forward_pass_batch_of_one() {
  function test_batched_backward_pass (line 659) | fn test_batched_backward_pass() {
  function test_bidirectional (line 691) | fn test_bidirectional() {
  function display_lstm (line 900) | fn display_lstm() {
  function display_bilstm (line 912) | fn display_bilstm() {

FILE: crates/burn-nn/src/modules/rope_encoding.rs
  type RotaryEncodingConfig (line 17) | pub struct RotaryEncodingConfig {
    method init (line 36) | pub fn init<B: Backend>(&self, device: &B::Device) -> RotaryEncoding<B> {
    method init_with_frequency_scaling (line 47) | pub fn init_with_frequency_scaling<B: Backend>(
    method initialize (line 61) | fn initialize<B: Backend>(
  type RotaryEncoding (line 109) | pub struct RotaryEncoding<B: Backend> {
  method custom_settings (line 119) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 125) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 148) | pub fn forward<const D: usize>(&self, x: Tensor<B, D>) -> Tensor<B, D> {
  function apply (line 165) | pub fn apply<const D: usize>(&self, x: Tensor<B, D>, start: usize) -> Te...
  function shift (line 203) | pub fn shift(&mut self, start: usize) {
  function compute_rotary_frequencies (line 244) | fn compute_rotary_frequencies(range: Range<usize>, theta: Tensor<B, 1>) ...
  type FT (line 275) | type FT = FloatElem<TestBackend>;
  function test_rotary_encoding_forward (line 278) | fn test_rotary_encoding_forward() {
  function test_rotary_encoding_3d (line 315) | fn test_rotary_encoding_3d() {
  function test_zero_input_rotary_encoding_forward (line 351) | fn test_zero_input_rotary_encoding_forward() {
  function test_valid_input_hidden_dim (line 381) | fn test_valid_input_hidden_dim() {
  function test_rotary_encoding_frequencies (line 392) | fn test_rotary_encoding_frequencies() {
  function apply_freq_scaling_by_parts (line 423) | fn apply_freq_scaling_by_parts<B: Backend>(freqs: Tensor<B, 1>) -> Tenso...
  function test_rotary_encoding_with_frequency_scaling (line 462) | fn test_rotary_encoding_with_frequency_scaling() {
  function test_rotary_encoding_shift_full (line 495) | fn test_rotary_encoding_shift_full() {
  function test_rotary_encoding_shift (line 525) | fn test_rotary_encoding_shift() {
  function test_rotary_encoding_shift_multiple (line 555) | fn test_rotary_encoding_shift_multiple() {
  function test_rotary_encoding_shift_should_increase (line 564) | fn test_rotary_encoding_shift_should_increase() {
  function display (line 572) | fn display() {

FILE: crates/burn-nn/src/modules/transformer/decoder.rs
  type TransformerDecoderConfig (line 20) | pub struct TransformerDecoderConfig {
    method init (line 113) | pub fn init<B: Backend>(&self, device: &B::Device) -> TransformerDecod...
  type TransformerDecoder (line 65) | pub struct TransformerDecoder<B: Backend> {
  method custom_settings (line 92) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 98) | fn custom_content(&self, content: Content) -> Option<Content> {
  type TransformerDecoderInput (line 133) | pub struct TransformerDecoderInput<B: Backend> {
  function new (line 144) | pub fn new(target: Tensor<B, 3>, memory: Tensor<B, 3>) -> Self {
  function memory_mask_pad (line 156) | pub fn memory_mask_pad(mut self, mask_pad: Tensor<B, 2, Bool>) -> Self {
  function memory_mask_attn (line 162) | pub fn memory_mask_attn(mut self, mask_attn: Tensor<B, 3, Bool>) -> Self {
  function target_mask_pad (line 168) | pub fn target_mask_pad(mut self, mask_pad: Tensor<B, 2, Bool>) -> Self {
  function target_mask_attn (line 174) | pub fn target_mask_attn(mut self, mask_attn: Tensor<B, 3, Bool>) -> Self {
  type TransformerDecoderLayer (line 182) | pub struct TransformerDecoderLayer<B: Backend> {
  type TransformerDecoderLayerAutoregressiveCache (line 202) | pub struct TransformerDecoderLayerAutoregressiveCache<B: Backend> {
  function empty (line 219) | pub fn empty() -> Self {
  type TransformerDecoderAutoregressiveCache (line 234) | pub struct TransformerDecoderAutoregressiveCache<B: Backend> {
  function empty (line 239) | fn empty(num_layers: usize) -> Self {
  function new (line 250) | pub fn new(config: &TransformerDecoderConfig, device: &B::Device) -> Self {
  function forward (line 291) | pub fn forward(&self, mut input: TransformerDecoderInput<B>) -> Transfor...
  function forward_autoregressive_inference (line 361) | pub fn forward_autoregressive_inference(
  function forward (line 457) | pub fn forward(&self, mut input: TransformerDecoderInput<B>) -> Tensor<B...
  function forward_autoregressive_inference (line 466) | pub fn forward_autoregressive_inference(
  function new_autoregressive_cache (line 481) | pub fn new_autoregressive_cache(&self) -> TransformerDecoderAutoregressi...
  type FT (line 494) | type FT = FloatElem<TestBackend>;
  function test_autoregressive_norm_last (line 497) | fn test_autoregressive_norm_last() {
  function test_autoregressive_norm_first (line 509) | fn test_autoregressive_norm_first() {
  function test_autoregressive (line 519) | fn test_autoregressive(config: TransformerDecoderConfig) {
  function display (line 563) | fn display() {

FILE: crates/burn-nn/src/modules/transformer/encoder.rs
  type TransformerEncoderConfig (line 18) | pub struct TransformerEncoderConfig {
    method init (line 141) | pub fn init<B: Backend>(&self, device: &B::Device) -> TransformerEncod...
  type TransformerEncoder (line 63) | pub struct TransformerEncoder<B: Backend> {
  method custom_settings (line 90) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 96) | fn custom_content(&self, content: Content) -> Option<Content> {
  type TransformerEncoderInput (line 111) | pub struct TransformerEncoderInput<B: Backend> {
  function new (line 119) | pub fn new(tensor: Tensor<B, 3>) -> Self {
  function mask_pad (line 128) | pub fn mask_pad(mut self, mask_pad: Tensor<B, 2, Bool>) -> Self {
  function mask_attn (line 134) | pub fn mask_attn(mut self, mask_attn: Tensor<B, 3, Bool>) -> Self {
  function forward (line 166) | pub fn forward(&self, input: TransformerEncoderInput<B>) -> Tensor<B, 3> {
  function forward_autoregressive_inference (line 181) | pub fn forward_autoregressive_inference(
  function new_autoregressive_cache (line 204) | pub fn new_autoregressive_cache(&self) -> TransformerEncoderAutoregressi...
  type TransformerEncoderLayer (line 211) | pub struct TransformerEncoderLayer<B: Backend> {
  function new (line 229) | pub fn new(config: &TransformerEncoderConfig, device: &B::Device) -> Self {
  function forward (line 264) | pub fn forward(
  function forward_autoregressive_inference (line 316) | pub fn forward_autoregressive_inference(
  type TransformerEncoderLayerAutoregressiveCache (line 380) | pub struct TransformerEncoderLayerAutoregressiveCache<B: Backend> {
  function empty (line 393) | pub fn empty() -> Self {
  type TransformerEncoderAutoregressiveCache (line 406) | pub struct TransformerEncoderAutoregressiveCache<B: Backend> {
  function empty (line 411) | fn empty(num_layers: usize) -> Self {
  type FT (line 426) | type FT = FloatElem<TestBackend>;
  function test_autoregressive_norm_last (line 429) | fn test_autoregressive_norm_last() {
  function test_autoregressive_norm_first (line 438) | fn test_autoregressive_norm_first() {
  function test_autoregressive (line 445) | fn test_autoregressive(config: TransformerEncoderConfig) {
  function display (line 479) | fn display() {

FILE: crates/burn-nn/src/modules/transformer/pwff.rs
  type PositionWiseFeedForwardConfig (line 11) | pub struct PositionWiseFeedForwardConfig {
    method init (line 72) | pub fn init<B: Backend>(&self, device: &B::Device) -> PositionWiseFeed...
  type PositionWiseFeedForward (line 41) | pub struct PositionWiseFeedForward<B: Backend> {
  method custom_settings (line 53) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 59) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 93) | pub fn forward<const D: usize>(&self, input: Tensor<B, D>) -> Tensor<B, ...
  function display (line 108) | fn display() {

FILE: crates/burn-nn/src/modules/unfold.rs
  type Unfold4dConfig (line 13) | pub struct Unfold4dConfig {
    method init (line 62) | pub fn init(&self) -> Unfold4d {
  type Unfold4d (line 32) | pub struct Unfold4d {
    method forward (line 81) | pub fn forward<B: Backend>(&self, input: Tensor<B, 4>) -> Tensor<B, 3> {
  method custom_settings (line 44) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 50) | fn custom_content(&self, content: Content) -> Option<Content> {
  function display (line 95) | fn display() {

FILE: crates/burn-nn/src/padding.rs
  function calculate_same_padding (line 8) | fn calculate_same_padding(kernel_size: usize, stride: usize, size_in: us...
  type PaddingConfig1d (line 23) | pub enum PaddingConfig1d {
    method calculate_padding_1d_pair (line 37) | pub(crate) fn calculate_padding_1d_pair(
  type PaddingConfig2d (line 53) | pub enum PaddingConfig2d {
    method calculate_padding_2d_pairs (line 67) | pub(crate) fn calculate_padding_2d_pairs(
    method calculate_padding_2d (line 88) | pub(crate) fn calculate_padding_2d(
  type PaddingConfig3d (line 106) | pub enum PaddingConfig3d {
    method calculate_padding_3d (line 119) | pub(crate) fn calculate_padding_3d(
  function test_padding_config_1d_calculate_pair_valid (line 153) | fn test_padding_config_1d_calculate_pair_valid() {
  function test_padding_config_1d_calculate_pair_explicit (line 159) | fn test_padding_config_1d_calculate_pair_explicit() {
  function test_padding_config_1d_calculate_pair_same (line 165) | fn test_padding_config_1d_calculate_pair_same() {
  function test_padding_config_2d_calculate_pairs_valid (line 174) | fn test_padding_config_2d_calculate_pairs_valid() {
  function test_padding_config_2d_calculate_pairs_explicit (line 183) | fn test_padding_config_2d_calculate_pairs_explicit() {
  function test_padding_config_2d_calculate_symmetric_valid (line 192) | fn test_padding_config_2d_calculate_symmetric_valid() {
  function test_padding_config_2d_calculate_symmetric_explicit (line 201) | fn test_padding_config_2d_calculate_symmetric_explicit() {
  function test_padding_config_2d_calculate_symmetric_asymmetric_panics (line 213) | fn test_padding_config_2d_calculate_symmetric_asymmetric_panics() {
  function test_padding_config_3d_calculate_valid (line 221) | fn test_padding_config_3d_calculate_valid() {
  function test_padding_config_3d_calculate_explicit (line 230) | fn test_padding_config_3d_calculate_explicit() {
  function test_padding_config_3d_calculate_same_odd_kernel (line 239) | fn test_padding_config_3d_calculate_same_odd_kernel() {

FILE: crates/burn-nn/tests/quantize.rs
  type B (line 22) | pub type B = burn_ndarray::NdArray<f32>;
  type B (line 26) | pub type B = burn_wgpu::Wgpu;
  type B (line 30) | pub type B = burn_cuda::Cuda;
  type B (line 34) | pub type B = burn_rocm::Rocm;
  function should_quantize_module (line 36) | fn should_quantize_module<M: Module<B>, const D: usize, F: Fn(&M) -> Ten...
  function should_quantize_transformer (line 58) | fn should_quantize_transformer() {
  function should_quantize_linear_128_256 (line 77) | fn should_quantize_linear_128_256() {
  function should_quantize_linear (line 95) | fn should_quantize_linear() {
  function should_quantize_linear_weights (line 116) | fn should_quantize_linear_weights() {
  function should_quantize_linear_blocks (line 133) | fn should_quantize_linear_blocks() {
  function should_quantize_linear_weights_blocks (line 152) | fn should_quantize_linear_weights_blocks() {

FILE: crates/burn-no-std-tests/src/burnpack.rs
  type TestModel (line 13) | pub struct TestModel<B: Backend> {
  function new (line 20) | pub fn new(device: &B::Device) -> Self {
  function forward (line 28) | pub fn forward(&self, x: Tensor<B, 2>) -> Tensor<B, 2> {
  function test_burnpack_basic (line 39) | pub fn test_burnpack_basic<B: Backend>(device: &B::Device) {
  function test_burnpack_filtering (line 69) | pub fn test_burnpack_filtering<B: Backend>(device: &B::Device) {
  function test_burnpack_metadata (line 96) | pub fn test_burnpack_metadata<B: Backend>(device: &B::Device) {
  function test_burnpack_match_all (line 125) | pub fn test_burnpack_match_all<B: Backend>(device: &B::Device) {
  function run_all_tests (line 151) | pub fn run_all_tests<B: Backend>(device: &B::Device) {

FILE: crates/burn-no-std-tests/src/conv.rs
  type ConvBlock (line 11) | pub struct ConvBlock<B: Backend> {
  type ConvBlockConfig (line 18) | pub struct ConvBlockConfig {
  function new (line 25) | pub fn new(config: &ConvBlockConfig, device: &B::Device) -> Self {
  function forward (line 42) | pub fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {

FILE: crates/burn-no-std-tests/src/mlp.rs
  type MlpConfig (line 14) | pub struct MlpConfig {
  type Mlp (line 28) | pub struct Mlp<B: Backend> {
  function new (line 36) | pub fn new(config: &MlpConfig, device: &B::Device) -> Self {
  function forward (line 56) | pub fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2> {

FILE: crates/burn-no-std-tests/src/model.rs
  type MnistConfig (line 16) | pub struct MnistConfig {
  type Model (line 30) | pub struct Model<B: Backend> {
  function new (line 39) | pub fn new(config: &MnistConfig, device: &B::Device) -> Self {
  function forward (line 54) | pub fn forward(&self, input: Tensor<B, 3>) -> Tensor<B, 2> {

FILE: crates/burn-no-std-tests/src/safetensors.rs
  type TestModel (line 13) | pub struct TestModel<B: Backend> {
  function new (line 19) | pub fn new(device: &B::Device) -> Self {
  function forward (line 26) | pub fn forward(&self, x: Tensor<B, 2>) -> Tensor<B, 2> {
  function test_safetensors_basic (line 33) | pub fn test_safetensors_basic<B: Backend>(device: &B::Device) {
  function test_safetensors_filtering (line 59) | pub fn test_safetensors_filtering<B: Backend>(device: &B::Device) {
  function test_safetensors_metadata (line 85) | pub fn test_safetensors_metadata<B: Backend>(device: &B::Device) {
  function run_all_tests (line 107) | pub fn run_all_tests<B: Backend>(device: &B::Device) {

FILE: crates/burn-no-std-tests/tests/burnpack_tests.rs
  function test_burnpack_no_std (line 4) | fn test_burnpack_no_std() {

FILE: crates/burn-no-std-tests/tests/safetensors_tests.rs
  function test_safetensors_no_std (line 4) | fn test_safetensors_no_std() {

FILE: crates/burn-no-std-tests/tests/test_integration.rs
  function test_mnist_model_with_random_input (line 10) | fn test_mnist_model_with_random_input() {

FILE: crates/burn-optim/src/grad_clipping/base.rs
  type GradientClippingConfig (line 8) | pub enum GradientClippingConfig {
    method init (line 22) | pub fn init(&self) -> GradientClipping {
  type GradientClipping (line 34) | pub enum GradientClipping {
    method clip_gradient (line 52) | pub fn clip_gradient<B: Backend, const D: usize>(&self, grad: Tensor<B...
    method clip_by_value (line 59) | fn clip_by_value<B: Backend, const D: usize>(
    method clip_by_norm (line 72) | fn clip_by_norm<B: Backend, const D: usize>(
    method l2_norm (line 83) | fn l2_norm<B: Backend, const D: usize>(tensor: Tensor<B, D>) -> Tensor...
  function test_clip_by_value (line 97) | fn test_clip_by_value() {
  function test_clip_by_norm (line 115) | fn test_clip_by_norm() {
  function test_clip_by_norm_no_clipping (line 132) | fn test_clip_by_norm_no_clipping() {

FILE: crates/burn-optim/src/lib.rs
  type LearningRate (line 28) | pub type LearningRate = f64;
  type TestBackend (line 38) | pub type TestBackend = burn_ndarray::NdArray<f32>;
  type TestBackend (line 42) | pub type TestBackend = burn_tch::LibTorch<f32>;
  type TestBackend (line 46) | pub type TestBackend = burn_wgpu::Wgpu;
  type TestBackend (line 50) | pub type TestBackend = burn_cuda::Cuda;
  type TestBackend (line 54) | pub type TestBackend = burn_rocm::Rocm;
  type TestAutodiffBackend (line 58) | pub type TestAutodiffBackend = burn_autodiff::Autodiff<TestBackend>;

FILE: crates/burn-optim/src/lr_scheduler/base.rs
  type LrScheduler (line 10) | pub trait LrScheduler: Clone + Send + Sync {
    method step (line 16) | fn step(&mut self) -> LearningRate;
    method to_record (line 19) | fn to_record<B: Backend>(&self) -> Self::Record<B>;
    method load_record (line 22) | fn load_record<B: Backend>(self, record: Self::Record<B>) -> Self;
  constant LOOSE_EPSILON (line 33) | const LOOSE_EPSILON: LearningRate = 1e-10;
  function check_lr_sequence (line 35) | pub fn check_lr_sequence<I, S>(mut scheduler: S, expected_lrs: I)
  function check_save_load (line 55) | pub fn check_save_load<S>(mut scheduler: S, save_at_step: usize)
  function compare_steps (line 74) | pub fn compare_steps<S: LrScheduler>(a: &mut S, b: &mut S, num_steps: us...

FILE: crates/burn-optim/src/lr_scheduler/composed.rs
  type ComposedLrSchedulerConfig (line 16) | pub struct ComposedLrSchedulerConfig {
    method init (line 43) | pub fn init(&self) -> Result<ComposedLrScheduler, String> {
    method linear (line 64) | pub fn linear(mut self, config: LinearLrSchedulerConfig) -> Self {
    method cosine (line 70) | pub fn cosine(mut self, config: CosineAnnealingLrSchedulerConfig) -> S...
    method exponential (line 76) | pub fn exponential(mut self, config: ExponentialLrSchedulerConfig) -> ...
    method noam (line 82) | pub fn noam(mut self, config: NoamLrSchedulerConfig) -> Self {
  type ComposedLrScheduler (line 25) | pub struct ComposedLrScheduler {
  type SchedulerReduction (line 32) | pub enum SchedulerReduction {
  type LrSchedulerConfig (line 89) | enum LrSchedulerConfig {
  type LrSchedulerItem (line 97) | enum LrSchedulerItem {
  type LrSchedulerRecord (line 106) | pub enum LrSchedulerRecord<B: Backend> {
  type ComposedLrSchedulerRecord (line 119) | pub struct ComposedLrSchedulerRecord<B: Backend> {
  type Record (line 124) | type Record<B: Backend> = ComposedLrSchedulerRecord<B>;
  method step (line 126) | fn step(&mut self) -> LearningRate {
  method to_record (line 150) | fn to_record<B: Backend>(&self) -> Self::Record<B> {
  method load_record (line 171) | fn load_record<B: Backend>(mut self, record: Self::Record<B>) -> Self {

FILE: crates/burn-optim/src/lr_scheduler/constant.rs
  type ConstantLr (line 14) | pub struct ConstantLr {
    method from (line 19) | fn from(lr: LearningRate) -> Self {
  type Record (line 25) | type Record<B: Backend> = ();
  method step (line 27) | fn step(&mut self) -> LearningRate {
  method to_record (line 31) | fn to_record<B: Backend>(&self) -> Self::Record<B> {}
  method load_record (line 33) | fn load_record<B: Backend>(self, _record: Self::Record<B>) -> Self {
  type Record (line 39) | type Record<B: Backend> = ();
  method step (line 41) | fn step(&mut self) -> LearningRate {
  method to_record (line 45) | fn to_record<B: Backend>(&self) -> Self::Record<B> {}
  method load_record (line 47) | fn load_record<B: Backend>(self, _record: Self::Record<B>) -> Self {

FILE: crates/burn-optim/src/lr_scheduler/cosine.rs
  type CosineAnnealingLrSchedulerConfig (line 15) | pub struct CosineAnnealingLrSchedulerConfig {
    method init (line 36) | pub fn init(&self) -> Result<CosineAnnealingLrScheduler, String> {
  type CosineAnnealingLrScheduler (line 66) | pub struct CosineAnnealingLrScheduler {
  type Record (line 74) | type Record<B: Backend> = usize;
  method step (line 76) | fn step(&mut self) -> LearningRate {
  method to_record (line 89) | fn to_record<B: Backend>(&self) -> Self::Record<B> {
  method load_record (line 93) | fn load_record<B: Backend>(mut self, record: Self::Record<B>) -> Self {
  function config_initial_lr_too_low (line 105) | fn config_initial_lr_too_low() {
  function config_initial_lr_too_high (line 116) | fn config_initial_lr_too_high() {
  function config_min_lr_too_low (line 127) | fn config_min_lr_too_low() {
  function config_min_lr_too_high (line 141) | fn config_min_lr_too_high() {
  function config_num_iters_too_low (line 155) | fn config_num_iters_too_low() {
  function test_lr_change (line 166) | fn test_lr_change() {
  function test_save_and_load (line 184) | fn test_save_and_load() {

FILE: crates/burn-optim/src/lr_scheduler/exponential.rs
  type ExponentialLrSchedulerConfig (line 14) | pub struct ExponentialLrSchedulerConfig {
    method init (line 30) | pub fn init(&self) -> Result<ExponentialLrScheduler, String> {
  type ExponentialLrScheduler (line 51) | pub struct ExponentialLrScheduler {
  type Record (line 59) | type Record<B: Backend> = LearningRate;
  method step (line 61) | fn step(&mut self) -> LearningRate {
  method to_record (line 66) | fn to_record<B: Backend>(&self) -> Self::Record<B> {
  method load_record (line 70) | fn load_record<B: Backend>(mut self, record: Self::Record<B>) -> Self {
  function config_initial_lr_too_low (line 82) | fn config_initial_lr_too_low() {
  function config_initial_lr_too_high (line 93) | fn config_initial_lr_too_high() {
  function config_gamma_too_low (line 104) | fn config_gamma_too_low() {
  function config_gamma_too_high (line 115) | fn config_gamma_too_high() {
  function test_lr_change (line 126) | fn test_lr_change() {
  function test_save_and_load (line 133) | fn test_save_and_load() {

FILE: crates/burn-optim/src/lr_scheduler/linear.rs
  type LinearLrSchedulerConfig (line 15) | pub struct LinearLrSchedulerConfig {
    method init (line 34) | pub fn init(&self) -> Result<LinearLrScheduler, String> {
  type LinearLrScheduler (line 57) | pub struct LinearLrScheduler {
  type Record (line 67) | type Record<B: Backend> = usize;
  method step (line 69) | fn step(&mut self) -> LearningRate {
  method to_record (line 74) | fn to_record<B: Backend>(&self) -> Self::Record<B> {
  method load_record (line 78) | fn load_record<B: Backend>(mut self, record: Self::Record<B>) -> Self {
  function config_initial_lr_too_low (line 90) | fn config_initial_lr_too_low() {
  function config_initial_lr_too_high (line 101) | fn config_initial_lr_too_high() {
  function config_final_lr_too_low (line 112) | fn config_final_lr_too_low() {
  function config_final_lr_too_high (line 123) | fn config_final_lr_too_high() {
  function config_num_iters_too_low (line 134) | fn config_num_iters_too_low() {
  function test_lr_decreasing (line 145) | fn test_lr_decreasing() {
  function test_lr_increasing (line 152) | fn test_lr_increasing() {
  function test_lr_unchanging (line 159) | fn test_lr_unchanging() {
  function test_save_and_load (line 166) | fn test_save_and_load() {

FILE: crates/burn-optim/src/lr_scheduler/noam.rs
  type NoamLrSchedulerConfig (line 11) | pub struct NoamLrSchedulerConfig {
    method init (line 40) | pub fn init(&self) -> Result<NoamLrScheduler, String> {
  type NoamLrScheduler (line 24) | pub struct NoamLrScheduler {
  type Record (line 60) | type Record<B: Backend> = usize;
  method step (line 62) | fn step(&mut self) -> LearningRate {
  method to_record (line 71) | fn to_record<B: Backend>(&self) -> Self::Record<B> {
  method load_record (line 75) | fn load_record<B: Backend>(mut self, record: Self::Record<B>) -> Self {
  function test_config_warmup_steps_invalid (line 86) | fn test_config_warmup_steps_invalid() {
  function test_config_warmup_steps_valid (line 92) | fn test_config_warmup_steps_valid() {
  function test_config_model_size_invalid (line 98) | fn test_config_model_size_invalid() {
  function test_config_model_size_valid (line 104) | fn test_config_model_size_valid() {
  function test_function_increase_and_decrease (line 110) | fn test_function_increase_and_decrease() {

FILE: crates/burn-optim/src/lr_scheduler/step.rs
  type StepLrSchedulerConfig (line 23) | pub struct StepLrSchedulerConfig {
    method init (line 40) | pub fn init(&self) -> Result<StepLrScheduler, String> {
  type StepLrScheduler (line 73) | pub struct StepLrScheduler {
  type Record (line 83) | type Record<B: Backend> = i32;
  method step (line 85) | fn step(&mut self) -> LearningRate {
  method to_record (line 97) | fn to_record<B: Backend>(&self) -> Self::Record<B> {
  method load_record (line 101) | fn load_record<B: Backend>(mut self, record: Self::Record<B>) -> Self {
  function test_config_step_size_zero (line 132) | fn test_config_step_size_zero() {
  function test_config_step_size_nonzero (line 138) | fn test_config_step_size_nonzero() {
  function test_config_default_gamma (line 144) | fn test_config_default_gamma() {
  function test_lr_decreasing (line 159) | fn test_lr_decreasing() {
  function test_lr_increasing (line 169) | fn test_lr_increasing() {
  function test_lr_unchanging (line 179) | fn test_lr_unchanging() {
  function test_save_and_load (line 189) | fn test_save_and_load() {
  function test_number_of_calls_within_limit (line 202) | fn test_number_of_calls_within_limit() {
  function test_number_of_calls_over_limit (line 211) | fn test_number_of_calls_over_limit() {

FILE: crates/burn-optim/src/optim/adagrad.rs
  type AdaGradConfig (line 18) | pub struct AdaGradConfig {
    method init (line 81) | pub fn init<B: AutodiffBackend, M: AutodiffModule<B>>(
  type AdaGrad (line 31) | pub struct AdaGrad {
    type State (line 43) | type State<const D: usize> = AdaGradState<B, D>;
    method step (line 45) | fn step<const D: usize>(
    method to_device (line 69) | fn to_device<const D: usize>(mut state: Self::State<D>, device: &Devic...
  type AdaGradState (line 38) | pub struct AdaGradState<B: Backend, const D: usize> {
  type LrDecayState (line 102) | pub struct LrDecayState<B: Backend, const D: usize> {
  type LrDecay (line 108) | struct LrDecay {
    method transform (line 114) | pub fn transform<B: Backend, const D: usize>(
  function to_device (line 148) | pub fn to_device(mut self, device: &B::Device) -> Self {
  constant LEARNING_RATE (line 166) | const LEARNING_RATE: LearningRate = 0.01;
  function test_adagrad_optimizer_save_load_state (line 169) | fn test_adagrad_optimizer_save_load_state() {
  function test_adagrad_optimizer_with_numbers (line 209) | fn test_adagrad_optimizer_with_numbers() {
  function given_linear_layer (line 284) | fn given_linear_layer(weight: TensorData, bias: TensorData) -> Linear<Te...
  function create_adagrad (line 294) | fn create_adagrad()

FILE: crates/burn-optim/src/optim/adam.rs
  type AdamConfig (line 22) | pub struct AdamConfig {
    method init (line 99) | pub fn init<B: AutodiffBackend, M: AutodiffModule<B>>(&self) -> Optimi...
  type Adam (line 47) | pub struct Adam {
    type State (line 60) | type State<const D: usize> = AdamState<B, D>;
    method step (line 62) | fn step<const D: usize>(
    method to_device (line 87) | fn to_device<const D: usize>(mut state: Self::State<D>, device: &Devic...
  type AdamState (line 54) | pub struct AdamState<B: Backend, const D: usize> {
  type AdaptiveMomentumState (line 120) | pub struct AdaptiveMomentumState<B: Backend, const D: usize> {
  type AdaptiveMomentum (line 133) | struct AdaptiveMomentum {
    method transform (line 141) | pub fn transform<B: Backend, const D: usize>(
  function to_device (line 216) | pub fn to_device(mut self, device: &B::Device) -> Self {
  constant LEARNING_RATE (line 236) | const LEARNING_RATE: LearningRate = 0.01;
  function test_adam_optimizer_save_load_state (line 239) | fn test_adam_optimizer_save_load_state() {
  function test_adam_optimizer_with_amsgrad_50_steps (line 278) | fn test_adam_optimizer_with_amsgrad_50_steps() {
  function test_adam_optimizer_with_numbers (line 379) | fn test_adam_optimizer_with_numbers() {
  function test_adam_optimizer_no_nan (line 457) | fn test_adam_optimizer_no_nan() {
  function given_linear_layer (line 498) | fn given_linear_layer(weight: TensorData, bias: TensorData) -> Linear<Te...
  function create_adam (line 508) | fn create_adam() -> OptimizerAdaptor<Adam, Linear<TestAutodiffBackend>, ...

FILE: crates/burn-optim/src/optim/adamw.rs
  type AdamWConfig (line 17) | pub struct AdamWConfig {
    method init (line 121) | pub fn init<B: AutodiffBackend, M: AutodiffModule<B>>(&self) -> Optimi...
  type AdamW (line 53) | pub struct AdamW {
    type State (line 67) | type State<const D: usize> = AdamWState<B, D>;
    method step (line 70) | fn step<const D: usize>(
    method to_device (line 109) | fn to_device<const D: usize>(mut state: Self::State<D>, device: &Devic...
  type AdamWState (line 61) | pub struct AdamWState<B: Backend, const D: usize> {
  type AdaptiveMomentumW (line 142) | struct AdaptiveMomentumW {
    method transform (line 150) | pub fn transform<B: Backend, const D: usize>(
  type FT (line 231) | type FT = FloatElem<TestAutodiffBackend>;
  constant LEARNING_RATE (line 233) | const LEARNING_RATE: LearningRate = 0.01;
  function test_adamw_optimizer_save_load_state (line 236) | fn test_adamw_optimizer_save_load_state() {
  function test_adamw_optimizer_with_amsgrad_50_steps (line 275) | fn test_adamw_optimizer_with_amsgrad_50_steps() {
  function test_adamw_optimizer_with_numbers (line 376) | fn test_adamw_optimizer_with_numbers() {
  function test_adamw_optimizer_with_numbers_cautious (line 453) | fn test_adamw_optimizer_with_numbers_cautious() {
  function test_adam_optimizer_no_nan (line 533) | fn test_adam_optimizer_no_nan() {
  function given_linear_layer (line 574) | fn given_linear_layer(weight: TensorData, bias: TensorData) -> Linear<Te...
  function create_adamw (line 584) | fn create_adamw() -> OptimizerAdaptor<AdamW, Linear<TestAutodiffBackend>...

FILE: crates/burn-optim/src/optim/base.rs
  type MultiGradientsParams (line 17) | pub struct MultiGradientsParams {
    method remove (line 28) | pub fn remove<B: Backend, const D: usize>(
    method select (line 47) | fn select<B: Backend, const D: usize>(
  type Optimizer (line 67) | pub trait Optimizer<M, B>: Send + Clone
    method step (line 77) | fn step(&mut self, lr: LearningRate, module: M, grads: GradientsParams...
    method step_multi (line 81) | fn step_multi(&mut self, lr: LearningRate, module: M, grads: MultiGrad...
    method to_record (line 84) | fn to_record(&self) -> Self::Record;
    method load_record (line 87) | fn load_record(self, record: Self::Record) -> Self;

FILE: crates/burn-optim/src/optim/decay.rs
  type WeightDecayConfig (line 10) | pub struct WeightDecayConfig {
  type WeightDecayState (line 17) | pub struct WeightDecayState<B: Backend, const D: usize> {
  type WeightDecay (line 23) | pub struct WeightDecay {
    method new (line 29) | pub fn new(config: &WeightDecayConfig) -> Self {
    method transform (line 45) | pub fn transform<B: Backend, const D: usize>(
  function to_device (line 64) | pub fn to_device(mut self, device: &B::Device) -> Self {

FILE: crates/burn-optim/src/optim/grad_accum.rs
  type GradientsAccumulator (line 11) | pub struct GradientsAccumulator<M> {
  method default (line 17) | fn default() -> Self {
  function new (line 24) | pub fn new() -> Self {
  function accumulate (line 34) | pub fn accumulate<B: AutodiffBackend>(&mut self, module: &M, grads: Grad...
  function grads (line 43) | pub fn grads(&mut self) -> GradientsParams {
  type ModuleGradsAccumulator (line 52) | struct ModuleGradsAccumulator<'a, M> {
  function visit_float (line 59) | fn visit_float<const D: usize>(&mut self, param: &Param<Tensor<B, D>>) {
  function test_accumulate_gradients_one_step (line 84) | fn test_accumulate_gradients_one_step() {
  function test_accumulate_gradients_two_steps (line 98) | fn test_accumulate_gradients_two_steps() {
  function layer (line 114) | fn layer<B: Backend>(device: &B::Device) -> Linear<B> {
  function random_tensor (line 118) | fn random_tensor<B: Backend>(device: &B::Device) -> Tensor<B, 2> {

FILE: crates/burn-optim/src/optim/grads.rs
  type GradientsParams (line 20) | pub struct GradientsParams {
    method new (line 26) | pub fn new() -> Self {
    method from_grads (line 34) | pub fn from_grads<B: AutodiffBackend, M: AutodiffModule<B>>(
    method from_module (line 43) | pub fn from_module<B: AutodiffBackend, M: AutodiffModule<B>>(
    method from_params (line 54) | pub fn from_params<B: AutodiffBackend, M: AutodiffModule<B>>(
    method get (line 72) | pub fn get<B, const D: usize>(&self, id: ParamId) -> Option<Tensor<B, D>>
    method remove (line 80) | pub fn remove<B, const D: usize>(&mut self, id: ParamId) -> Option<Ten...
    method register (line 92) | pub fn register<B, const D: usize>(&mut self, id: ParamId, value: Tens...
    method len (line 100) | pub fn len(&self) -> usize {
    method is_empty (line 105) | pub fn is_empty(&self) -> bool {
    method to_device (line 110) | pub fn to_device<B: AutodiffBackend, M: AutodiffModule<B>>(
    method all_reduce (line 122) | pub fn all_reduce<B: Backend>(
  function test_convert_grads (line 167) | fn test_convert_grads() {
  function layer (line 185) | fn layer<B: Backend>(device: &B::Device) -> Linear<B> {
  function random_tensor (line 189) | fn random_tensor<B: Backend>(device: &B::Device) -> Tensor<B, 2> {

FILE: crates/burn-optim/src/optim/lbfgs.rs
  function cubic_interpolate (line 25) | fn cubic_interpolate(
  type LineSearchSample (line 59) | struct LineSearchSample<B: Backend> {
  function strong_wolfe (line 71) | fn strong_wolfe<B: Backend, F>(
  type LineSearchFn (line 309) | pub enum LineSearchFn {
  type LBFGSConfig (line 321) | pub struct LBFGSConfig {
    method init (line 348) | pub fn init<B: AutodiffBackend>(&self) -> LBFGS<B> {
  type FlattenGradsVisitorInner (line 366) | struct FlattenGradsVisitorInner<'a, B: AutodiffBackend> {
  function visit_float (line 372) | fn visit_float<const D: usize>(&mut self, param: &Param<Tensor<B, D>>) {
  function flatten_params_inner (line 381) | fn flatten_params_inner<B: AutodiffBackend, M: Module<B>>(
  type FlattenParamsVisitorInner (line 395) | struct FlattenParamsVisitorInner<'a, B: AutodiffBackend> {
  function visit_float (line 400) | fn visit_float<const D: usize>(&mut self, param: &Param<Tensor<B, D>>) {
  function flatten_grads_inner (line 408) | fn flatten_grads_inner<B: AutodiffBackend, M: Module<B>>(
  type ParamsFromFlatMapperInner (line 425) | struct ParamsFromFlatMapperInner<'a, B: AutodiffBackend> {
  function take_slice (line 431) | fn take_slice(&mut self, numel: usize) -> Tensor<B::InnerBackend, 1> {
  function map_float (line 439) | fn map_float<const D: usize>(&mut self, param: Param<Tensor<B, D>>) -> P...
  function set_params_from_flat_inner (line 450) | fn set_params_from_flat_inner<B: AutodiffBackend, M: Module<B>>(
  type LBFGSState (line 464) | pub struct LBFGSState<B: Backend> {
  function to_device (line 483) | pub fn to_device(self, device: &B::Device) -> Self {
  method default (line 504) | fn default() -> Self {
  type LBFGS (line 527) | pub struct LBFGS<B: Backend + AutodiffBackend> {
  function step (line 534) | pub fn step<M, F>(&mut self, lr: LearningRate, mut module: M, mut closur...
  function to_device (line 740) | pub fn to_device(self, device: &B::Device) -> Self {
  function given_linear_layer (line 759) | fn given_linear_layer(weight: TensorData, bias: TensorData) -> Linear<Te...
  function test_cubic_interpolate (line 769) | fn test_cubic_interpolate() {
  function test_strong_wolfe_direct_comparison (line 832) | fn test_strong_wolfe_direct_comparison() {
  function test_lbfgs_strong_wolfe_comparison (line 896) | fn test_lbfgs_strong_wolfe_comparison() {
  function test_lbfgs_no_strong_wolfe_comparison (line 937) | fn test_lbfgs_no_strong_wolfe_comparison() {

FILE: crates/burn-optim/src/optim/momentum.rs
  type MomentumConfig (line 10) | pub struct MomentumConfig {
  type MomentumState (line 25) | pub struct MomentumState<B: Backend, const D: usize> {
  type Momentum (line 31) | pub struct Momentum<B: Backend> {
  function new (line 39) | pub fn new(config: &MomentumConfig) -> Self {
  function transform (line 58) | pub fn transform<const D: usize>(
  function to_device (line 90) | pub fn to_device(mut self, device: &B::Device) -> Self {

FILE: crates/burn-optim/src/optim/muon.rs
  type AdjustLrFn (line 32) | pub enum AdjustLrFn {
    method adjustment_ratio (line 66) | fn adjustment_ratio(&self, shape: &[usize]) -> f64 {
  type MuonConfig (line 126) | pub struct MuonConfig {
    method init (line 195) | pub fn init<B: AutodiffBackend, M: AutodiffModule<B>>(
  type NewtonSchulzParams (line 215) | struct NewtonSchulzParams {
    method new (line 223) | fn new(coefficients: (f32, f32, f32), steps: usize) -> Self {
  type Muon (line 251) | pub struct Muon<B: Backend> {
  function adjust_lr (line 276) | fn adjust_lr(&self, lr: LearningRate, shape: &[usize]) -> LearningRate {
  function zeropower_via_newtonschulz (line 299) | fn zeropower_via_newtonschulz<const D: usize>(&self, g: Tensor<B, D>) ->...
  type MuonState (line 351) | pub struct MuonState<B: Backend, const D: usize> {
  type State (line 357) | type State<const D: usize> = MuonState<B, D>;
  function step (line 378) | fn step<const D: usize>(
  function to_device (line 417) | fn to_device<const D: usize>(mut state: Self::State<D>, device: &Device<...
  type TestBackend (line 432) | type TestBackend = burn_ndarray::NdArray<f32>;
  constant TOLERANCE (line 434) | const TOLERANCE: f64 = 1e-8;
  function given_linear_layer_no_bias (line 436) | fn given_linear_layer_no_bias(weight: TensorData) -> Linear<TestAutodiff...
  function test_adjust_lr_fn_original (line 450) | fn test_adjust_lr_fn_original() {
  function test_adjust_lr_fn_match_rms_adamw (line 468) | fn test_adjust_lr_fn_match_rms_adamw() {
  function test_1d_tensor_panics (line 484) | fn test_1d_tensor_panics() {
  function test_muon_optimizer_save_load_state (line 502) | fn test_muon_optimizer_save_load_state() {
  function test_muon_with_weight_decay (line 529) | fn test_muon_with_weight_decay() {
  function test_newton_schulz_orthogonalization (line 566) | fn test_newton_schulz_orthogonalization() {
  function test_tall_matrix_transpose (line 599) | fn test_tall_matrix_transpose() {
  function test_zero_gradient (line 673) | fn test_zero_gradient() {

FILE: crates/burn-optim/src/optim/rmsprop.rs
  type RmsPropConfig (line 18) | pub struct RmsPropConfig {
    method init (line 43) | pub fn init<B: AutodiffBackend, M: AutodiffModule<B>>(
  type RmsProp (line 69) | pub struct RmsProp {
    type State (line 79) | type State<const D: usize> = RmsPropState<B, D>;
    method step (line 81) | fn step<const D: usize>(
    method to_device (line 129) | fn to_device<const D: usize>(mut state: Self::State<D>, device: &Devic...
  type RmsPropState (line 139) | pub struct RmsPropState<B: Backend, const D: usize> {
  type SquareAvgState (line 150) | pub struct SquareAvgState<B: Backend, const D: usize> {
  function transform (line 157) | fn transform(alpha: f32, grad: Tensor<B, D>, state: Option<Self>) -> (Te...
  function to_device (line 182) | pub fn to_device(mut self, device: &B::Device) -> Self {
  type CenteredState (line 190) | pub struct CenteredState<B: Backend, const D: usize> {
  function transform (line 199) | fn transform(
  function to_device (line 250) | pub fn to_device(mut self, device: &B::Device) -> Self {
  type RmsPropMomentum (line 260) | pub struct RmsPropMomentum {
    method transform (line 267) | fn transform<B: Backend, const D: usize>(
  type RmsPropMomentumState (line 297) | pub struct RmsPropMomentumState<B: Backend, const D: usize> {
  function to_device (line 311) | pub fn to_device(mut self, device: &B::Device) -> Self {
  type FT (line 329) | type FT = FloatElem<TestAutodiffBackend>;
  constant LEARNING_RATE (line 331) | const LEARNING_RATE: LearningRate = 0.01;
  function test_rmsprop_optimizer_save_load_state (line 334) | fn test_rmsprop_optimizer_save_load_state() {
  function test_rmsprop_optimizer_with_numbers_basic (line 375) | fn test_rmsprop_optimizer_with_numbers_basic() {
  function test_rmsprop_optimizer_with_numbers (line 451) | fn test_rmsprop_optimizer_with_numbers() {
  function given_linear_layer (line 535) | fn given_linear_layer(weight: TensorData, bias: TensorData) -> Linear<Te...
  function create_random_tensor (line 546) | fn create_random_tensor() -> Tensor<TestAutodiffBackend, 2> {
  function create_rmsprop (line 554) | fn create_rmsprop()

FILE: crates/burn-optim/src/optim/sgd.rs
  type SgdConfig (line 17) | pub struct SgdConfig {
    method init (line 44) | pub fn init<B: AutodiffBackend, M: AutodiffModule<B>>(
  type Sgd (line 30) | pub struct Sgd<B: Backend> {
  type SgdState (line 37) | pub struct SgdState<B: Backend, const D: usize> {
  type State (line 62) | type State<const D: usize> = SgdState<B, D>;
  function step (line 64) | fn step<const D: usize>(
  function to_device (line 93) | fn to_device<const D: usize>(mut state: Self::State<D>, device: &B::Devi...
  constant LEARNING_RATE (line 110) | const LEARNING_RATE: LearningRate = 0.02;
  function with_updated_params_should_have_state (line 113) | fn with_updated_params_should_have_state() {
  function without_updated_params_should_not_have_state (line 128) | fn without_updated_params_should_not_have_state() {
  function can_attach_gradient_clipping (line 135) | fn can_attach_gradient_clipping() {
  function should_load_state (line 141) | fn should_load_state() {
  function random_tensor (line 160) | fn random_tensor<B: Backend>(device: &B::Device) -> Tensor<B, 2> {
  function layer (line 164) | fn layer<B: Backend>(device: &B::Device) -> Linear<B> {
  function sgd_with_all (line 168) | fn sgd_with_all()

FILE: crates/burn-optim/src/optim/simple/adaptor.rs
  type OptimizerAdaptor (line 18) | pub struct OptimizerAdaptor<O, M, B>
  function from (line 36) | fn from(optim: O) -> Self {
  function with_grad_clipping (line 61) | pub fn with_grad_clipping(mut self, gradient_clipping: GradientClipping)...
  function has_gradient_clipping (line 67) | pub(crate) fn has_gradient_clipping(&self) -> bool {
  type Record (line 78) | type Record = HashMap<ParamId, AdaptorRecord<O, B>>;
  function step (line 80) | fn step(&mut self, lr: LearningRate, module: M, grads: GradientsParams) ...
  function step_multi (line 93) | fn step_multi(&mut self, lr: LearningRate, module: M, grads: crate::Mult...
  function to_record (line 106) | fn to_record(&self) -> Self::Record {
  function load_record (line 110) | fn load_record(mut self, record: Self::Record) -> Self {
  type GradAdaptor (line 116) | enum GradAdaptor {
    method remove (line 122) | fn remove<B: Backend, const D: usize>(
  type SimpleOptimizerMapper (line 137) | struct SimpleOptimizerMapper<'a, M, B, O>
  function map_float (line 157) | fn map_float<const D: usize>(&mut self, param: Param<Tensor<B, D>>) -> P...

FILE: crates/burn-optim/src/optim/simple/base.rs
  type SimpleOptimizer (line 12) | pub trait SimpleOptimizer<B>: Send + Sync + Clone
    method step (line 23) | fn step<const D: usize>(
    method to_device (line 35) | fn to_device<const D: usize>(state: Self::State<D>, device: &B::Device...

FILE: crates/burn-optim/src/optim/simple/record/base.rs
  type AdaptorRecord (line 12) | pub enum AdaptorRecord<O, B>
  type AdaptorRecordItem (line 24) | pub enum AdaptorRecordItem<
  type Item (line 38) | type Item<S: PrecisionSettings> = AdaptorRecordItem<O, B, S>;
  function into_item (line 40) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {
  function from_item (line 46) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, device: &B::Devi...
  method clone (line 58) | fn clone(&self) -> Self {
  function into_state (line 75) | pub fn into_state<const D: usize>(self) -> O::State<D> {
  function from_state (line 90) | pub fn from_state<const D: usize>(state: O::State<D>) -> Self {

FILE: crates/burn-optim/src/optim/simple/record/v1.rs
  type AdaptorRecordV1 (line 13) | pub enum AdaptorRecordV1<O: SimpleOptimizer<B>, B: Backend> {
  method clone (line 43) | fn clone(&self) -> Self {
  type AdaptorRecordItemV1 (line 61) | pub enum AdaptorRecordItemV1<O: SimpleOptimizer<B>, B: Backend, S: Preci...
  function into_state (line 104) | pub fn into_state<const D: usize>(self) -> O::State<D> {
  function from_state (line 131) | pub fn from_state<const D: usize>(state: O::State<D>) -> Self {
  type Item (line 154) | type Item<S: PrecisionSettings> = AdaptorRecordItemV1<O, B, S>;
  function into_item (line 156) | fn into_item<S: PrecisionSettings>(self) -> Self::Item<S> {
  function from_item (line 170) | fn from_item<S: PrecisionSettings>(item: Self::Item<S>, device: &B::Devi...

FILE: crates/burn-optim/src/optim/visitor.rs
  type GradientsParamsConverter (line 12) | pub struct GradientsParamsConverter<'a, M: AutodiffModule<B>, B: Autodif...
  type GradientsParamsChangeDevice (line 20) | pub struct GradientsParamsChangeDevice<'a, M: AutodiffModule<B>, B: Auto...
  function visit_float (line 31) | fn visit_float<const D: usize>(&mut self, param: &Param<Tensor<B, D>>) {
  function visit_float (line 52) | fn visit_float<const D: usize>(&mut self, param: &Param<Tensor<B, D>>) {

FILE: crates/burn-remote/src/client/base.rs
  type RemoteClient (line 14) | pub struct RemoteClient {
    method init (line 21) | pub fn init<C: ProtocolClient>(device: RemoteDevice) -> Self {
    method new (line 25) | pub(crate) fn new(
  type RemoteSender (line 44) | pub(crate) struct RemoteSender {
    method new_tensor_id (line 60) | pub(crate) fn new_tensor_id(&self) -> TensorId {
    method next_position (line 68) | fn next_position(&self) -> u64 {
    method send (line 73) | pub(crate) fn send(&self, task: ComputeTask) {
    method send_async (line 82) | pub(crate) fn send_async(
    method close (line 110) | pub(crate) fn close(&mut self) {
  type RemoteSendError (line 53) | pub enum RemoteSendError {
  method drop (line 120) | fn drop(&mut self) {

FILE: crates/burn-remote/src/client/channel.rs
  type RemoteChannel (line 14) | pub struct RemoteChannel<C: ProtocolClient> {
  type Device (line 19) | type Device = RemoteDevice;
  type Bridge (line 20) | type Bridge = RemoteBridge<C>;
  type Client (line 21) | type Client = RemoteClient;
  type FloatElem (line 23) | type FloatElem = f32;
  type IntElem (line 25) | type IntElem = i32;
  type BoolElem (line 27) | type BoolElem = u32;
  method name (line 29) | fn name(device: &Self::Device) -> String {
  method init_client (line 33) | fn init_client(device: &Self::Device) -> Self::Client {
  method get_tensor_handle (line 37) | fn get_tensor_handle(tensor: &TensorIr, client: &Self::Client) -> Remote...
  method register_tensor (line 45) | fn register_tensor(
  method change_client_backend (line 57) | fn change_client_backend(
  method clone (line 79) | fn clone(&self) -> Self {

FILE: crates/burn-remote/src/client/runner.rs
  function get_address_registry (line 14) | fn get_address_registry() -> &'static Mutex<HashMap<String, u32>> {
  function address_to_id (line 23) | pub fn address_to_id<S: AsRef<str>>(address: S) -> u32 {
  function id_to_address (line 35) | pub fn id_to_address(id: u32) -> Option<String> {
  type Device (line 52) | type Device = RemoteDevice;
  method register_op (line 54) | fn register_op(&self, op: burn_ir::OperationIr) {
  method read_tensor_async (line 59) | fn read_tensor_async(
  method register_tensor_data (line 80) | fn register_tensor_data(&self, data: TensorData) -> RouterTensor<Self> {
  method device (line 90) | fn device(&self) -> Self::Device {
  method sync (line 94) | fn sync(&self) -> Result<(), ExecutionError> {
  method seed (line 110) | fn seed(&self, seed: u64) {
  method create_empty_handle (line 114) | fn create_empty_handle(&self) -> burn_ir::TensorId {
  method dtype_usage (line 118) | fn dtype_usage(&self, dtype: burn_std::DType) -> burn_backend::DTypeUsag...
  type RemoteDevice (line 130) | pub struct RemoteDevice {
    method new (line 138) | pub fn new(address: &str) -> Self {
    method from_id (line 159) | fn from_id(device_id: DeviceId) -> Self {
    method to_id (line 168) | fn to_id(&self) -> DeviceId {
    method device_count (line 175) | fn device_count(_type_id: u16) -> usize {
  method default (line 148) | fn default() -> Self {
  type RemoteBridge (line 182) | pub struct RemoteBridge<C: ProtocolClient> {
  type RemoteTensorHandle (line 186) | pub struct RemoteTensorHandle<C: ProtocolClient> {
  function get_next_transfer_id (line 194) | fn get_next_transfer_id() -> TensorTransferId {
  function change_backend (line 214) | pub(crate) fn change_backend(mut self, target_device: &RemoteDevice) -> ...
  type TensorHandle (line 242) | type TensorHandle = RemoteTensorHandle<C>;
  type Device (line 243) | type Device = RemoteDevice;
  method change_backend_float (line 245) | fn change_backend_float(
  method change_backend_int (line 253) | fn change_backend_int(
  method change_backend_bool (line 261) | fn change_backend_bool(
  function test_address_to_id (line 275) | fn test_address_to_id() {

FILE: crates/burn-remote/src/client/worker.rs
  type CallbackSender (line 6) | pub type CallbackSender = async_channel::Sender<TaskResponseContent>;
  type ClientRequest (line 9) | pub enum ClientRequest {
  type ClientWorker (line 14) | pub(crate) struct ClientWorker<C: ProtocolClient> {
  function on_response (line 20) | async fn on_response(&mut self, response: TaskResponse) {
  function register_callback (line 31) | fn register_callback(&mut self, id: ConnectionId, callback: CallbackSend...
  function start (line 37) | pub fn start(device: RemoteDevice) -> RemoteClient {
  method default (line 123) | fn default() -> Self {

FILE: crates/burn-remote/src/lib.rs
  type RemoteBackend (line 33) | pub type RemoteBackend = BackendRouter<RemoteChannel<<RemoteProtocol as ...
  function test_to_device_over_websocket (line 47) | pub fn test_to_device_over_websocket() {

FILE: crates/burn-remote/src/server/base.rs
  type RemoteServer (line 17) | pub struct RemoteServer<B, P>
  function start (line 32) | pub async fn start(device: Device<B>, server: P::Server) {
  function handle_socket_response (line 51) | async fn handle_socket_response(
  function handle_socket_request (line 90) | async fn handle_socket_request(
  function start_websocket_async (line 173) | pub async fn start_websocket_async<B: BackendIr>(device: Device<B>, port...
  function start_websocket (line 180) | pub async fn start_websocket<B: BackendIr>(device: Device<B>, port: u16) {

FILE: crates/burn-remote/src/server/processor.rs
  type Processor (line 16) | pub struct Processor<B, P>
  type Callback (line 25) | pub type Callback<M> = Sender<M>;
  type ProcessorTask (line 27) | pub enum ProcessorTask {
  function start (line 48) | pub async fn start(

FILE: crates/burn-remote/src/server/session.rs
  type SessionManager (line 20) | pub struct SessionManager<B, P>
  type Session (line 30) | struct Session<B, P>
  function new (line 47) | pub fn new(device: Device<B>, data_service: Arc<TensorDataService<B, P>>...
  function register_responder (line 57) | pub async fn register_responder(
  function stream (line 70) | pub async fn stream(
  function close (line 104) | pub async fn close(&self, session_id: Option<SessionId>) {
  function register_session (line 113) | fn register_session(&self, sessions: &mut HashMap<SessionId, Session<B, ...
  function new (line 127) | fn new(runner: Runner<B>, data_service: Arc<TensorDataService<B, P>>) ->...
  function init_responder (line 139) | fn init_responder(&mut self) -> Receiver<Receiver<TaskResponse>> {
  function select (line 146) | async fn select(&mut self, stream_id: StreamId) -> Stream<B, P> {
  function close (line 164) | async fn close(&mut self) {

FILE: crates/burn-remote/src/server/stream.rs
  type Stream (line 20) | pub struct Stream<B, P>
  function new (line 36) | pub async fn new(
  function register_operation (line 51) | pub async fn register_operation(&self, op: Box<OperationIr>) {
  function register_tensor (line 58) | pub async fn register_tensor(&self, tensor_id: TensorId, data: TensorDat...
  function register_tensor_remote (line 65) | pub async fn register_tensor_remote(&self, tensor: TensorRemote, new_id:...
  function expose_tensor_remote (line 72) | pub async fn expose_tensor_remote(
  function read_tensor (line 88) | pub async fn read_tensor(&self, id: ConnectionId, desc: TensorIr) {
  function sync (line 99) | pub async fn sync(&self, id: ConnectionId) {
  function close (line 110) | pub async fn close(&self) {
  function seed (line 117) | pub async fn seed(&self, seed: u64) {
  function supports_dtype (line 124) | pub async fn supports_dtype(&self, id: ConnectionId, dtype: DType) {

FILE: crates/burn-remote/src/shared/mod.rs
  type RemoteProtocol (line 7) | pub(crate) type RemoteProtocol = burn_communication::websocket::WebSocket;

FILE: crates/burn-remote/src/shared/task.rs
  type ConnectionId (line 13) | pub struct ConnectionId {
  type SessionId (line 20) | pub struct SessionId {
    method new (line 33) | pub fn new() -> Self {
  method fmt (line 25) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Task (line 42) | pub enum Task {
  type TensorRemote (line 50) | pub struct TensorRemote {
  type ComputeTask (line 57) | pub enum ComputeTask {
  type TaskResponse (line 74) | pub struct TaskResponse {
  type TaskResponseContent (line 81) | pub enum TaskResponseContent {

FILE: crates/burn-rl/src/environment/base.rs
  type StepResult (line 2) | pub struct StepResult<S> {
  type Environment (line 14) | pub trait Environment {
    constant MAX_STEPS (line 21) | const MAX_STEPS: usize;
    method state (line 24) | fn state(&self) -> Self::State;
    method step (line 26) | fn step(&mut self, action: Self::Action) -> StepResult<Self::State>;
    method reset (line 28) | fn reset(&mut self);
  type EnvironmentInit (line 33) | pub trait EnvironmentInit<E: Environment>: Clone {
    method init (line 35) | fn init(&self) -> E;
  method init (line 43) | fn init(&self) -> E {

FILE: crates/burn-rl/src/lib.rs
  type TestBackend (line 18) | pub(crate) type TestBackend = burn_ndarray::NdArray<f32>;
  type MockPolicy (line 35) | pub(crate) struct MockPolicy {}
    method new (line 38) | pub fn new() -> Self {
    type Observation (line 44) | type Observation = MockObservation;
    type ActionDistribution (line 45) | type ActionDistribution = MockActionDistribution;
    type Action (line 46) | type Action = MockAction;
    type ActionContext (line 47) | type ActionContext = MockActionContext;
    type PolicyState (line 48) | type PolicyState = MockPolicyState;
    method forward (line 50) | fn forward(&mut self, obs: Self::Observation) -> Self::ActionDistribut...
    method action (line 59) | fn action(
    method update (line 79) | fn update(&mut self, _update: Self::PolicyState) {}
    method state (line 81) | fn state(&self) -> Self::PolicyState {
    method load_record (line 85) | fn load_record(
  type MockObservation (line 95) | pub(crate) struct MockObservation(pub Vec<f32>);
  type MockAction (line 99) | pub(crate) struct MockAction(pub Vec<i32>);
  type MockActionDistribution (line 103) | pub(crate) struct MockActionDistribution(Vec<f32>);
  type MockActionContext (line 106) | pub(crate) struct MockActionContext;
  type MockPolicyState (line 110) | pub(crate) struct MockPolicyState;
    type Record (line 118) | type Record = MockRecord;
    method into_record (line 120) | fn into_record(self) -> Self::Record {
    method load_record (line 124) | fn load_record(&self, _record: Self::Record) -> Self {
  type MockRecord (line 113) | pub(crate) struct MockRecord {
  method batch (line 130) | fn batch(items: Vec<Self>) -> Self {
  method unbatch (line 134) | fn unbatch(self) -> Vec<Self> {
  method batch (line 140) | fn batch(items: Vec<Self>) -> Self {
  method unbatch (line 144) | fn unbatch(self) -> Vec<Self> {
  method batch (line 154) | fn batch(items: Vec<Self>) -> Self {
  method unbatch (line 158) | fn unbatch(self) -> Vec<Self> {

FILE: crates/burn-rl/src/policy/async_policy.rs
  type PolicyInferenceServer (line 15) | struct PolicyInferenceServer<B: Backend, P: Policy<B>> {
  function new (line 33) | pub fn new(max_autobatch_size: usize, inner_policy: P) -> Self {
  function push_action (line 43) | pub fn push_action(&mut self, item: ActionItem<P::Observation, P::Action...
  function push_logits (line 55) | pub fn push_logits(&mut self, item: ForwardItem<P::Observation, P::Actio...
  function len_actions (line 67) | pub fn len_actions(&self) -> usize {
  function len_logits (line 71) | pub fn len_logits(&self) -> usize {
  function flush_actions (line 75) | pub fn flush_actions(&mut self) {
  function flush_logits (line 102) | pub fn flush_logits(&mut self) {
  function update_policy (line 121) | pub fn update_policy(&mut self, policy_update: P::PolicyState) {
  function state (line 131) | pub fn state(&self) -> P::PolicyState {
  function increment_agents (line 135) | pub fn increment_agents(&mut self, num: usize) {
  function decrement_agents (line 139) | pub fn decrement_agents(&mut self, num: usize) {
  type InferenceMessage (line 160) | enum InferenceMessage<B: Backend, P: Policy<B>> {
  type ActionItem (line 170) | struct ActionItem<S, A, C> {
  type ForwardItem (line 177) | struct ForwardItem<S, O> {
  type AsyncPolicy (line 184) | pub struct AsyncPolicy<B: Backend, P: Policy<B>> {
  function new (line 204) | pub fn new(autobatch_size: usize, inner_policy: P) -> Self {
  function increment_agents (line 234) | pub fn increment_agents(&self, num: usize) {
  function decrement_agents (line 241) | pub fn decrement_agents(&self, num: usize) {
  type ActionContext (line 253) | type ActionContext = P::ActionContext;
  type PolicyState (line 254) | type PolicyState = P::PolicyState;
  type Observation (line 256) | type Observation = P::Observation;
  type ActionDistribution (line 257) | type ActionDistribution = P::ActionDistribution;
  type Action (line 258) | type Action = P::Action;
  function forward (line 260) | fn forward(&mut self, states: Self::Observation) -> Self::ActionDistribu...
  function action (line 274) | fn action(
  function update (line 294) | fn update(&mut self, update: Self::PolicyState) {
  function state (line 300) | fn state(&self) -> Self::PolicyState {
  function load_record (line 310) | fn load_record(self, _record: <Self::PolicyState as PolicyState<B>>::Rec...
  function test_multiple_actions_before_flush (line 328) | fn test_multiple_actions_before_flush() {
  function test_multiple_forward_before_flush (line 369) | fn test_multiple_forward_before_flush() {
  function test_async_policy_deterministic_behaviour (line 410) | fn test_async_policy_deterministic_behaviour() {
  function flush_when_running_agents_smaller_than_autobatch_size (line 445) | fn flush_when_running_agents_smaller_than_autobatch_size() {

FILE: crates/burn-rl/src/policy/base.rs
  type ActionContext (line 9) | pub struct ActionContext<A, C> {
  type PolicyState (line 17) | pub trait PolicyState<B: Backend> {
    method into_record (line 22) | fn into_record(self) -> Self::Record;
    method load_record (line 24) | fn load_record(&self, record: Self::Record) -> Self;
  type Policy (line 28) | pub trait Policy<B: Backend>: Clone {
    method forward (line 42) | fn forward(&mut self, obs: Self::Observation) -> Self::ActionDistribut...
    method action (line 44) | fn action(
    method update (line 51) | fn update(&mut self, update: Self::PolicyState);
    method state (line 53) | fn state(&self) -> Self::PolicyState;
    method load_record (line 56) | fn load_record(self, record: <Self::PolicyState as PolicyState<B>>::Re...
  type Batchable (line 60) | pub trait Batchable: Sized {
    method batch (line 62) | fn batch(value: Vec<Self>) -> Self;
    method unbatch (line 64) | fn unbatch(self) -> Vec<Self>;
  type RLTrainOutput (line 68) | pub struct RLTrainOutput<TO, P> {
  type LearnerTransitionBatch (line 76) | pub type LearnerTransitionBatch<B, P> =
  type PolicyLearner (line 80) | pub trait PolicyLearner<B>
    method train (line 95) | fn train(
    method policy (line 100) | fn policy(&self) -> Self::InnerPolicy;
    method update_policy (line 102) | fn update_policy(&mut self, update: Self::InnerPolicy);
    method record (line 105) | fn record(&self) -> Self::Record;
    method load_record (line 107) | fn load_record(self, record: Self::Record) -> Self;

FILE: crates/burn-rl/src/transition_buffer/base.rs
  type Transition (line 8) | pub struct Transition<B: Backend, S, A> {
  type TransitionBatch (line 22) | pub struct TransitionBatch<B: Backend, SB, AB> {
  type TransitionBuffer (line 40) | pub struct TransitionBuffer<B: Backend, SB: SliceAccess<B>, AB: SliceAcc...
  function new (line 54) | pub fn new(capacity: usize, device: &B::Device) -> Self {
  function ensure_init (line 68) | fn ensure_init(&mut self, state: &SB, next_state: &SB, action: &AB) {
  function push (line 79) | pub fn push(&mut self, state: SB, next_state: SB, action: AB, reward: f3...
  function sample (line 117) | pub fn sample(&self, batch_size: usize) -> TransitionBatch<B, SB, AB> {
  function len (line 157) | pub fn len(&self) -> usize {
  function is_empty (line 162) | pub fn is_empty(&self) -> bool {
  function capacity (line 167) | pub fn capacity(&self) -> usize {
  type TB (line 177) | type TB = Tensor<TestBackend, 2>;
  function push_transition (line 179) | fn push_transition(
  function push_increment_len (line 191) | fn push_increment_len() {
  function push_overwrites_when_full (line 206) | fn push_overwrites_when_full() {
  function sample_returns_correct_shapes (line 219) | fn sample_returns_correct_shapes() {
  function sample_panics_when_batch_too_large (line 237) | fn sample_panics_when_batch_too_large() {

FILE: crates/burn-rl/src/transition_buffer/slice_access.rs
  type SliceAccess (line 11) | pub trait SliceAccess<B: Backend>: Clone + Sized {
    method zeros_like (line 14) | fn zeros_like(sample: &Self, capacity: usize, device: &B::Device) -> S...
    method select (line 17) | fn select(self, dim: usize, indices: Tensor<B, 1, Int>) -> Self;
    method slice_assign_inplace (line 20) | fn slice_assign_inplace(&mut self, index: usize, value: Self);
  function zeros_like (line 24) | fn zeros_like(sample: &Self, capacity: usize, device: &B::Device) -> Self {
  function select (line 29) | fn select(self, dim: usize, indices: Tensor<B, 1, Int>) -> Self {
  function slice_assign_inplace (line 33) | fn slice_assign_inplace(&mut self, index: usize, value: Self) {

FILE: crates/burn-rocm/src/lib.rs
  type Rocm (line 11) | pub type Rocm<F = f32, I = i32, B = u8> = CubeBackend<HipRuntime, F, I, B>;
  type Rocm (line 14) | pub type Rocm<F = f32, I = i32, B = u8> = burn_fusion::Fusion<CubeBacken...

FILE: crates/burn-router/src/backend.rs
  type BackendRouter (line 7) | pub struct BackendRouter<R: RunnerChannel> {
  function fmt (line 12) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  method clone (line 18) | fn clone(&self) -> Self {
  method default (line 24) | fn default() -> Self {
  method scheme (line 30) | fn scheme(&self) -> &QuantScheme {
  type Device (line 41) | type Device = R::Device;
  type FloatTensorPrimitive (line 43) | type FloatTensorPrimitive = RouterTensor<R::Client>;
  type FloatElem (line 45) | type FloatElem = R::FloatElem;
  type IntTensorPrimitive (line 47) | type IntTensorPrimitive = RouterTensor<R::Client>;
  type IntElem (line 49) | type IntElem = R::IntElem;
  type BoolTensorPrimitive (line 51) | type BoolTensorPrimitive = RouterTensor<R::Client>;
  type BoolElem (line 53) | type BoolElem = R::BoolElem;
  type QuantizedTensorPrimitive (line 55) | type QuantizedTensorPrimitive = RouterTensor<R::Client>;
  method name (line 57) | fn name(device: &Self::Device) -> String {
  method seed (line 61) | fn seed(device: &Self::Device, seed: u64) {
  method sync (line 66) | fn sync(device: &Self::Device) -> Result<(), ExecutionError> {
  method dtype_usage (line 71) | fn dtype_usage(device: &Self::Device, dtype: DType) -> burn_backend::DTy...

FILE: crates/burn-router/src/bridge/base.rs
  type MultiBackendBridge (line 4) | pub trait MultiBackendBridge: Send + Sync + 'static {
    method change_backend_float (line 11) | fn change_backend_float(
    method change_backend_int (line 18) | fn change_backend_int(
    method change_backend_bool (line 25) | fn change_backend_bool(

FILE: crates/burn-router/src/bridge/byte.rs
  type ByteBridge (line 4) | pub struct ByteBridge<Backends> {

FILE: crates/burn-router/src/channel/base.rs
  type TensorHandle (line 8) | pub type TensorHandle<Br> = <Br as MultiBackendBridge>::TensorHandle;
  type RunnerChannel (line 11) | pub trait RunnerChannel: Clone + Send + Sync + 'static + Sized {
    method name (line 26) | fn name(device: &Self::Device) -> String;
    method init_client (line 29) | fn init_client(device: &Self::Device) -> Self::Client;
    method get_tensor_handle (line 32) | fn get_tensor_handle(tensor: &TensorIr, client: &Self::Client) -> Tens...
    method register_tensor (line 35) | fn register_tensor(
    method change_client_backend (line 43) | fn change_client_backend(

FILE: crates/burn-router/src/channel/direct.rs
  type DirectChannel (line 4) | pub struct DirectChannel<Backends, Bridge> {
  method clone (line 10) | fn clone(&self) -> Self {

FILE: crates/burn-router/src/client/base.rs
  type Client (line 15) | pub type Client<R> = <R as RunnerChannel>::Client;
  type Key (line 18) | type Key = (core::any::TypeId, DeviceId);
  type RunnerClient (line 21) | pub trait RunnerClient: Clone + Send + Sync + Sized {
    method register_op (line 26) | fn register_op(&self, op: OperationIr);
    method register (line 30) | fn register(&self, op: OperationIr) -> Vec<RouterTensor<Self>> {
    method read_tensor_async (line 42) | fn read_tensor_async(&self, tensor: TensorIr) -> DynFut<Result<TensorD...
    method sync (line 44) | fn sync(&self) -> Result<(), ExecutionError>;
    method create_empty_handle (line 46) | fn create_empty_handle(&self) -> TensorId;
    method register_tensor_data (line 48) | fn register_tensor_data(&self, data: TensorData) -> RouterTensor<Self>;
    method device (line 50) | fn device(&self) -> Self::Device;
    method seed (line 52) | fn seed(&self, seed: u64);
    method dtype_usage (line 54) | fn dtype_usage(&self, dtype: DType) -> burn_backend::DTypeUsageSet;
  type RunnerClientLocator (line 57) | pub(crate) struct RunnerClientLocator {
    method new (line 75) | pub const fn new() -> Self {
    method client (line 84) | pub fn client<R: RunnerChannel + 'static>(&self, device: &R::Device) -...
    method register_inner (line 111) | fn register_inner<R: RunnerChannel + 'static>(
  function get_client (line 62) | pub fn get_client<R: RunnerChannel>(device: &R::Device) -> Client<R> {
  function new_client (line 69) | fn new_client<R: RunnerChannel>(device: &R::Device) -> Client<R> {

FILE: crates/burn-router/src/lib.rs
  type DirectByteChannel (line 27) | pub type DirectByteChannel<Backends> = DirectChannel<Backends, ByteBridg...
  type Router (line 36) | pub type Router<Backends> = BackendRouter<DirectByteChannel<Backends>>;
  type TestBackend1 (line 46) | pub type TestBackend1 = burn_ndarray::NdArray<f32, i32>;
  type TestBackend2 (line 47) | pub type TestBackend2 = burn_wgpu::Wgpu<f32, i32>;
  type TestBackend (line 48) | pub type TestBackend = BackendRouter<DirectByteChannel<(TestBackend1, Te...

FILE: crates/burn-router/src/ops/bool_tensor.rs
  function bool_empty (line 18) | fn bool_empty(shape: Shape, device: &Device<Self>) -> BoolTensor<Self> {
  function bool_zeros (line 28) | fn bool_zeros(shape: Shape, device: &Device<Self>) -> BoolTensor<Self> {
  function bool_ones (line 38) | fn bool_ones(shape: Shape, device: &Device<Self>) -> BoolTensor<Self> {
  function bool_into_data (line 48) | async fn bool_into_data(tensor: BoolTensor<Self>) -> Result<TensorData, ...
  function bool_from_data (line 52) | fn bool_from_data(data: TensorData, device: &Device<Self>) -> BoolTensor...
  function bool_into_int (line 65) | fn bool_into_int(tensor: BoolTensor<Self>) -> IntTensor<Self> {
  function bool_into_float (line 76) | fn bool_into_float(tensor: BoolTensor<Self>) -> FloatTensor<Self> {
  function bool_device (line 87) | fn bool_device(tensor: &BoolTensor<Self>) -> Device<Self> {
  function bool_to_device (line 91) | fn bool_to_device(tensor: BoolTensor<Self>, device: &Device<Self>) -> Bo...
  function bool_reshape (line 98) | fn bool_reshape(tensor: BoolTensor<Self>, shape: Shape) -> BoolTensor<Se...
  function bool_slice (line 107) | fn bool_slice(tensor: BoolTensor<Self>, slices: &[Slice]) -> BoolTensor<...
  function bool_slice_assign (line 118) | fn bool_slice_assign(
  function bool_equal (line 134) | fn bool_equal(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTenso...
  function bool_not (line 145) | fn bool_not(tensor: BoolTensor<Self>) -> BoolTensor<Self> {
  function bool_and (line 154) | fn bool_and(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTensor<...
  function bool_or (line 165) | fn bool_or(lhs: BoolTensor<Self>, rhs: BoolTensor<Self>) -> BoolTensor<S...
  function bool_swap_dims (line 176) | fn bool_swap_dims(tensor: BoolTensor<Self>, dim1: usize, dim2: usize) ->...
  function bool_permute (line 187) | fn bool_permute(tensor: BoolTensor<Self>, axes: &[usize]) -> BoolTensor<...
  function bool_flip (line 198) | fn bool_flip(tensor: BoolTensor<Self>, axes: &[usize]) -> BoolTensor<Sel...
  function bool_expand (line 209) | fn bool_expand(tensor: BoolTensor<Self>, shape: Shape) -> BoolTensor<Sel...
  function bool_cat (line 218) | fn bool_cat(tensors: Vec<BoolTensor<Self>>, dim: usize) -> BoolTensor<Se...
  function bool_repeat_dim (line 228) | fn bool_repeat_dim(tensor: BoolTensor<Self>, dim: usize, times: usize) -...
  function bool_unfold (line 239) | fn bool_unfold(
  function bool_mask_where (line 255) | fn bool_mask_where(
  function bool_mask_fill (line 270) | fn bool_mask_fill(
  function bool_gather (line 286) | fn bool_gather(
  function bool_scatter_or (line 301) | fn bool_scatter_or(
  function bool_equal_elem (line 322) | fn bool_equal_elem(lhs: BoolTensor<Self>, rhs: Scalar) -> BoolTensor<Sel...

FILE: crates/burn-router/src/ops/int_tensor.rs
  function int_empty (line 20) | fn int_empty(shape: Shape, device: &Device<Self>, dtype: IntDType) -> In...
  function int_into_data (line 29) | async fn int_into_data(tensor: IntTensor<Self>) -> Result<TensorData, Ex...
  function int_from_data (line 37) | fn int_from_data(data: TensorData, device: &Device<Self>) -> IntTensor<S...
  function int_device (line 50) | fn int_device(tensor: &IntTensor<Self>) -> Device<Self> {
  function int_to_device (line 54) | fn int_to_device(tensor: IntTensor<Self>, device: &Device<Self>) -> IntT...
  function int_reshape (line 61) | fn int_reshape(tensor: IntTensor<Self>, shape: Shape) -> IntTensor<Self> {
  function int_slice (line 70) | fn int_slice(tensor: IntTensor<Self>, slices: &[Slice]) -> IntTensor<Sel...
  function int_slice_assign (line 81) | fn int_slice_assign(
  function int_matmul (line 97) | fn int_matmul(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  function int_mask_where (line 108) | fn int_mask_where(
  function int_mask_fill (line 123) | fn int_mask_fill(
  function int_gather (line 139) | fn int_gather(
  function int_scatter_add (line 154) | fn int_scatter_add(
  function int_select (line 175) | fn int_select(
  function int_select_add (line 190) | fn int_select_add(
  function int_cat (line 211) | fn int_cat(tensors: Vec<IntTensor<Self>>, dim: usize) -> IntTensor<Self> {
  function int_equal (line 221) | fn int_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor<S...
  function int_equal_elem (line 235) | fn int_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Self> {
  function int_greater (line 247) | fn int_greater(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor...
  function int_greater_elem (line 264) | fn int_greater_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Sel...
  function int_greater_equal (line 279) | fn int_greater_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> Bool...
  function int_greater_equal_elem (line 296) | fn int_greater_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTens...
  function int_lower (line 311) | fn int_lower(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTensor<S...
  function int_lower_elem (line 328) | fn int_lower_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor<Self> {
  function int_lower_equal (line 343) | fn int_lower_equal(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> BoolTe...
  function int_lower_equal_elem (line 360) | fn int_lower_equal_elem(lhs: IntTensor<Self>, rhs: Scalar) -> BoolTensor...
  function int_add (line 375) | fn int_add(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_add_scalar (line 389) | fn int_add_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_sub (line 402) | fn int_sub(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_sub_scalar (line 416) | fn int_sub_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_mul (line 429) | fn int_mul(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_mul_scalar (line 443) | fn int_mul_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_div (line 456) | fn int_div(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<Self> {
  function int_div_scalar (line 470) | fn int_div_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Self> {
  function int_remainder (line 483) | fn int_remainder(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTenso...
  function int_remainder_scalar (line 497) | fn int_remainder_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<...
  function int_zeros (line 510) | fn int_zeros(shape: Shape, device: &Device<Self>, dtype: IntDType) -> In...
  function int_ones (line 519) | fn int_ones(shape: Shape, device: &Device<Self>, dtype: IntDType) -> Int...
  function int_sum (line 528) | fn int_sum(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_sum_dim (line 540) | fn int_sum_dim(tensor: IntTensor<Self>, axis: usize) -> IntTensor<Self> {
  function int_prod (line 552) | fn int_prod(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_prod_dim (line 564) | fn int_prod_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_mean (line 576) | fn int_mean(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_mean_dim (line 588) | fn int_mean_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cumsum (line 600) | fn int_cumsum(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cumprod (line 612) | fn int_cumprod(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cummin (line 624) | fn int_cummin(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_cummax (line 636) | fn int_cummax(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_argmax (line 648) | fn int_argmax(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_argmin (line 660) | fn int_argmin(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_clamp (line 672) | fn int_clamp(tensor: IntTensor<Self>, min: Scalar, max: Scalar) -> IntTe...
  function int_abs (line 686) | fn int_abs(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_into_float (line 698) | fn int_into_float(tensor: IntTensor<Self>) -> FloatTensor<Self> {
  function int_swap_dims (line 709) | fn int_swap_dims(tensor: IntTensor<Self>, dim1: usize, dim2: usize) -> I...
  function int_max (line 720) | fn int_max(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_max_dim (line 732) | fn int_max_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_max_dim_with_indices (line 744) | fn int_max_dim_with_indices(
  function int_max_abs (line 765) | fn int_max_abs(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_max_abs_dim (line 777) | fn int_max_abs_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Sel...
  function int_min (line 789) | fn int_min(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_min_dim (line 801) | fn int_min_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function int_min_dim_with_indices (line 813) | fn int_min_dim_with_indices(
  function int_random (line 834) | fn int_random(
  function int_permute (line 851) | fn int_permute(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Sel...
  function int_expand (line 862) | fn int_expand(tensor: IntTensor<Self>, shape: Shape) -> IntTensor<Self> {
  function int_flip (line 871) | fn int_flip(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Self> {
  function int_repeat_dim (line 882) | fn int_repeat_dim(tensor: IntTensor<Self>, dim: usize, times: usize) -> ...
  function bitwise_and (line 893) | fn bitwise_and(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  function bitwise_or (line 904) | fn bitwise_or(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  function bitwise_xor (line 915) | fn bitwise_xor(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  function bitwise_not (line 926) | fn bitwise_not(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function bitwise_and_scalar (line 935) | fn bitwise_and_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  function bitwise_or_scalar (line 945) | fn bitwise_or_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Sel...
  function bitwise_xor_scalar (line 955) | fn bitwise_xor_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  function bitwise_left_shift (line 965) | fn bitwise_left_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> Int...
  function bitwise_left_shift_scalar (line 976) | fn bitwise_left_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTe...
  function bitwise_right_shift (line 988) | fn bitwise_right_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> In...
  function bitwise_right_shift_scalar (line 999) | fn bitwise_right_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntT...
  function int_cast (line 1011) | fn int_cast(tensor: IntTensor<Self>, dtype: burn_backend::IntDType) -> I...
  function int_unfold (line 1022) | fn int_unfold(

FILE: crates/burn-router/src/ops/module.rs
  function conv1d (line 15) | fn conv1d(
  function conv1d_x_backward (line 35) | fn conv1d_x_backward(
  function conv1d_weight_backward (line 57) | fn conv1d_weight_backward(
  function conv1d_bias_backward (line 79) | fn conv1d_bias_backward(
  function conv2d (line 99) | fn conv2d(
  function conv2d_x_backward (line 119) | fn conv2d_x_backward(
  function conv2d_weight_backward (line 141) | fn conv2d_weight_backward(
  function conv2d_bias_backward (line 163) | fn conv2d_bias_backward(
  function conv3d (line 183) | fn conv3d(
  function conv3d_x_backward (line 203) | fn conv3d_x_backward(
  function conv3d_weight_backward (line 225) | fn conv3d_weight_backward(
  function conv3d_bias_backward (line 247) | fn conv3d_bias_backward(
  function conv_transpose1d (line 267) | fn conv_transpose1d(
  function conv_transpose2d (line 289) | fn conv_transpose2d(
  function conv_transpose3d (line 311) | fn conv_transpose3d(
  function avg_pool1d (line 333) | fn avg_pool1d(
  function avg_pool2d (line 357) | fn avg_pool2d(
  function avg_pool1d_backward (line 381) | fn avg_pool1d_backward(
  function avg_pool2d_backward (line 409) | fn avg_pool2d_backward(
  function max_pool1d (line 437) | fn max_pool1d(
  function max_pool2d (line 461) | fn max_pool2d(
  function max_pool1d_with_indices (line 485) | fn max_pool1d_with_indices(
  function max_pool2d_with_indices (line 514) | fn max_pool2d_with_indices(
  function max_pool1d_with_indices_backward (line 543) | fn max_pool1d_with_indices_backward(
  function max_pool2d_with_indices_backward (line 576) | fn max_pool2d_with_indices_backward(
  function adaptive_avg_pool1d (line 609) | fn adaptive_avg_pool1d(x: FloatTensor<Self>, output_size: usize) -> Floa...
  function adaptive_avg_pool2d (line 623) | fn adaptive_avg_pool2d(x: FloatTensor<Self>, output_size: [usize; 2]) ->...
  function adaptive_avg_pool1d_backward (line 637) | fn adaptive_avg_pool1d_backward(
  function adaptive_avg_pool2d_backward (line 654) | fn adaptive_avg_pool2d_backward(
  function interpolate (line 671) | fn interpolate(
  function interpolate_backward (line 686) | fn interpolate_backward(
  function deform_conv2d (line 708) | fn deform_conv2d(
  function deform_conv2d_backward (line 734) | fn deform_conv2d_backward(
  function attention (line 773) | fn attention(

FILE: crates/burn-router/src/ops/qtensor.rs
  function q_from_data (line 11) | fn q_from_data(_data: TensorData, _device: &Device<Self>) -> QuantizedTe...
  function quantize (line 15) | fn quantize(
  function quantize_dynamic (line 23) | fn quantize_dynamic(
  function dequantize (line 30) | fn dequantize(_tensor: QuantizedTensor<Self>) -> FloatTensor<Self> {
  function q_device (line 34) | fn q_device(_tensor: &QuantizedTensor<Self>) -> Device<Self> {
  function q_to_device (line 38) | fn q_to_device(
  function q_reshape (line 45) | fn q_reshape(_tensor: QuantizedTensor<Self>, _shape: Shape) -> Quantized...
  function q_into_data (line 49) | async fn q_into_data(_tensor: QuantizedTensor<Self>) -> Result<TensorDat...
  function q_swap_dims (line 53) | fn q_swap_dims(
  function q_permute (line 61) | fn q_permute(_tensor: QuantizedTensor<Self>, _axes: &[usize]) -> Quantiz...
  function q_flip (line 65) | fn q_flip(_tensor: QuantizedTensor<Self>, _axes: &[usize]) -> QuantizedT...
  function q_gather (line 69) | fn q_gather(
  function q_select (line 77) | fn q_select(
  function q_slice (line 85) | fn q_slice(_tensor: QuantizedTensor<Self>, _slices: &[Slice]) -> Quantiz...
  function q_expand (line 89) | fn q_expand(_tensor: QuantizedTensor<Self>, _shape: Shape) -> QuantizedT...

FILE: crates/burn-router/src/ops/tensor.rs
  function float_from_data (line 22) | fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTens...
  function float_random (line 35) | fn float_random(
  function float_zeros (line 49) | fn float_zeros(shape: Shape, device: &Device<Self>, dtype: FloatDType) -...
  function float_ones (line 58) | fn float_ones(shape: Shape, device: &Device<Self>, dtype: FloatDType) ->...
  function float_full (line 67) | fn float_full(
  function float_into_data (line 86) | async fn float_into_data(tensor: FloatTensor<Self>) -> Result<TensorData...
  function float_device (line 94) | fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {
  function float_to_device (line 98) | fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> ...
  function float_into_int (line 105) | fn float_into_int(tensor: FloatTensor<Self>) -> IntTensor<Self> {
  function float_empty (line 119) | fn float_empty(shape: Shape, device: &Device<Self>, dtype: FloatDType) -...
  function float_add (line 128) | fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_add_scalar (line 142) | fn float_add_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_clamp (line 155) | fn float_clamp(tensor: FloatTensor<Self>, min: Scalar, max: Scalar) -> F...
  function float_sub (line 169) | fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_sub_scalar (line 183) | fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_mul (line 196) | fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_mul_scalar (line 210) | fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_div (line 223) | fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTen...
  function float_div_scalar (line 237) | fn float_div_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatTensor<...
  function float_remainder (line 250) | fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Fl...
  function float_remainder_scalar (line 264) | fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatT...
  function float_matmul (line 277) | fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Float...
  function float_cross (line 291) | fn float_cross(
  function float_swap_dims (line 309) | fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) ...
  function float_reshape (line 320) | fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor...
  function float_gather (line 329) | fn float_gather(
  function float_scatter_add (line 344) | fn float_scatter_add(
  function float_select (line 365) | fn float_select(
  function float_select_add (line 380) | fn float_select_add(
  function float_slice (line 401) | fn float_slice(tensor: FloatTensor<Self>, slices: &[Slice]) -> FloatTens...
  function float_slice_assign (line 412) | fn float_slice_assign(
  function float_mask_where (line 428) | fn float_mask_where(
  function float_mask_fill (line 443) | fn float_mask_fill(
  function float_equal (line 459) | fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTe...
  function float_equal_elem (line 473) | fn float_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor<S...
  function float_greater (line 485) | fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> Bool...
  function float_greater_elem (line 502) | fn float_greater_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor...
  function float_greater_equal (line 517) | fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -...
  function float_greater_equal_elem (line 534) | fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> Bool...
  function float_lower (line 549) | fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTe...
  function float_lower_elem (line 566) | fn float_lower_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTensor<S...
  function float_lower_equal (line 581) | fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> ...
  function float_lower_equal_elem (line 598) | fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: Scalar) -> BoolTe...
  function float_sum (line 613) | fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sum_dim (line 625) | fn float_sum_dim(tensor: FloatTensor<Self>, axis: usize) -> FloatTensor<...
  function float_prod (line 637) | fn float_prod(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function float_prod_dim (line 649) | fn float_prod_dim(tensor: IntTensor<Self>, dim: usize) -> IntTensor<Self> {
  function float_mean (line 661) | fn float_mean(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_mean_dim (line 673) | fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<...
  function float_cumsum (line 685) | fn float_cumsum(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_cumprod (line 697) | fn float_cumprod(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_cummin (line 709) | fn float_cummin(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_cummax (line 721) | fn float_cummax(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Se...
  function float_exp (line 733) | fn float_exp(lhs: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_log (line 745) | fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_log1p (line 757) | fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_powf_scalar_impl (line 769) | fn float_powf_scalar_impl(lhs: FloatTensor<Self>, rhs: Scalar) -> FloatT...
  function float_sqrt (line 782) | fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_abs (line 794) | fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cos (line 806) | fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cosh (line 818) | fn float_cosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sin (line 830) | fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_sinh (line 842) | fn float_sinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_tan (line 854) | fn float_tan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_tanh (line 866) | fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_acos (line 878) | fn float_acos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_acosh (line 890) | fn float_acosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asin (line 902) | fn float_asin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asinh (line 914) | fn float_asinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan (line 926) | fn float_atan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atanh (line 938) | fn float_atanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan2 (line 950) | fn float_atan2(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatT...
  function float_round (line 964) | fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_floor (line 976) | fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_ceil (line 988) | fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_trunc (line 1000) | fn float_trunc(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_recip (line 1012) | fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_erf (line 1024) | fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_cat (line 1036) | fn float_cat(tensors: Vec<FloatTensor<Self>>, dim: usize) -> FloatTensor...
  function float_argmax (line 1046) | fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {
  function float_repeat_dim (line 1061) | fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize)...
  function float_argmin (line 1072) | fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {
  function float_max (line 1087) | fn float_max(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_max_dim (line 1099) | fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_max_dim_with_indices (line 1111) | fn float_max_dim_with_indices(
  function float_min (line 1132) | fn float_min(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_min_dim (line 1144) | fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<S...
  function float_min_dim_with_indices (line 1156) | fn float_min_dim_with_indices(
  function float_powf (line 1177) | fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTe...
  function float_permute (line 1191) | fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTens...
  function float_expand (line 1202) | fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<...
  function float_flip (line 1211) | fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<...
  function float_cast (line 1222) | fn float_cast(tensor: FloatTensor<Self>, dtype: burn_backend::FloatDType...
  function float_unfold (line 1233) | fn float_unfold(

FILE: crates/burn-router/src/runner.rs
  type RunnerContext (line 20) | pub struct RunnerContext<B: BackendIr> {
  function create_empty_handle (line 29) | fn create_empty_handle(&mut self) -> TensorId {
  type Runner (line 37) | pub struct Runner<B: BackendIr> {
  function fmt (line 44) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  function new (line 53) | pub fn new(device: B::Device) -> Self {
  function get_tensor_handle (line 63) | pub fn get_tensor_handle(&self, tensor: &TensorIr) -> B::Handle {
  function register_tensor (line 69) | pub fn register_tensor<C: RunnerClient>(
  function register_tensor_data_id (line 86) | pub fn register_tensor_data_id(&self, id: TensorId, data: TensorData) {
  function register_tensor_data_desc (line 107) | pub fn register_tensor_data_desc(&self, data: TensorData) -> TensorIr {
  type Device (line 139) | type Device = B::Device;
  method register_op (line 142) | fn register_op(&self, op: OperationIr) {
  method read_tensor_async (line 1530) | fn read_tensor_async(&self, tensor: TensorIr) -> DynFut<Result<TensorDat...
  method register_tensor_data (line 1561) | fn register_tensor_data(&self, data: TensorData) -> RouterTensor<Self> {
  method device (line 1566) | fn device(&self) -> Self::Device {
  method sync (line 1570) | fn sync(&self) -> Result<(), ExecutionError> {
  method seed (line 1574) | fn seed(&self, seed: u64) {
  method create_empty_handle (line 1578) | fn create_empty_handle(&self) -> TensorId {
  method dtype_usage (line 1583) | fn dtype_usage(&self, dtype: DType) -> burn_backend::DTypeUsageSet {

FILE: crates/burn-router/src/tensor.rs
  type RouterTensor (line 11) | pub struct RouterTensor<C: RunnerClient> {
  method dtype (line 21) | fn dtype(&self) -> DType {
  method shape (line 25) | fn shape(&self) -> Shape {
  method rank (line 29) | fn rank(&self) -> usize {
  function new (line 36) | pub fn new(id: TensorId, shape: Shape, dtype: DType, client: C) -> Self {
  function into_data (line 46) | pub(crate) async fn into_data(self) -> Result<TensorData, ExecutionError> {
  function into_ir (line 51) | pub fn into_ir(mut self) -> TensorIr {
  function to_ir_out (line 73) | pub(crate) fn to_ir_out(&self) -> TensorIr {
  function status (line 82) | pub(crate) fn status(&self, count: u32) -> TensorStatus {
  function fmt (line 92) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  method clone (line 107) | fn clone(&self) -> Self {
  method drop (line 121) | fn drop(&mut self) {

FILE: crates/burn-router/src/types.rs
  function should_support_dual_byte_bridge (line 374) | fn should_support_dual_byte_bridge() {

FILE: crates/burn-std/src/id.rs
  type IdGenerator (line 5) | pub struct IdGenerator {}
    method generate (line 9) | pub fn generate() -> u64 {
  function uniqueness_test (line 30) | fn uniqueness_test() {
  function thread_safety_test (line 44) | fn thread_safety_test() {

FILE: crates/burn-std/src/lib.rs
  function from (line 44) | fn from(dtype: DType) -> Self {
  function from (line 88) | fn from(dtype: DType) -> cubecl::ir::StorageType {

FILE: crates/burn-std/src/network.rs
  function download_file_as_bytes (line 21) | pub async fn download_file_as_bytes(url: &str, message: &str) -> Vec<u8> {

FILE: crates/burn-std/src/tensor/dtype.rs
  type DType (line 10) | pub enum DType {
    method from (line 30) | fn from(value: cubecl::ir::ElemType) -> Self {
    method size (line 67) | pub const fn size(&self) -> usize {
    method is_float (line 109) | pub fn is_float(&self) -> bool {
    method is_int (line 116) | pub fn is_int(&self) -> bool {
    method is_uint (line 120) | pub fn is_uint(&self) -> bool {
    method is_bool (line 125) | pub fn is_bool(&self) -> bool {
    method name (line 130) | pub fn name(&self) -> &'static str {
    method from (line 179) | fn from(value: FloatDType) -> Self {
    method from (line 220) | fn from(value: IntDType) -> Self {
    method from (line 265) | fn from(value: BoolDType) -> Self {
  type FloatDType (line 157) | pub enum FloatDType {
    method from (line 166) | fn from(value: DType) -> Self {
  type IntDType (line 192) | pub enum IntDType {
    method from (line 204) | fn from(value: DType) -> Self {
  type BoolStore (line 236) | pub enum BoolStore {
  type BoolDType (line 248) | pub type BoolDType = BoolStore;
    method from (line 252) | fn from(value: DType) -> Self {

FILE: crates/burn-std/src/tensor/mod.rs
  function is_contiguous (line 21) | pub fn is_contiguous(shape: &[usize], strides: &[usize]) -> bool {
  function contiguous_strides (line 39) | pub fn contiguous_strides(shape: &[usize]) -> Strides {
  type ReshapeAction (line 53) | pub enum ReshapeAction {
  type ReshapeAnalysis (line 67) | pub enum ReshapeAnalysis {
    method action (line 84) | fn action(self, shape: &[usize], strides: &[usize], shape_new: &[usize...
  function reshape_action (line 116) | pub fn reshape_action(shape: &[usize], strides: &[usize], shape_new: &[u...
  function broadcast_strides (line 121) | pub fn broadcast_strides(
  function split_strides (line 137) | pub fn split_strides(shape: &[usize], strides: &[usize], shape_new: &[us...
  function reshape_analysis (line 162) | pub fn reshape_analysis(

FILE: crates/burn-std/src/tensor/quantization.rs
  constant QPARAM_ALIGN (line 13) | pub const QPARAM_ALIGN: usize = core::mem::align_of::<f32>();
  type QuantAcc (line 26) | pub enum QuantAcc {
  type QuantPropagation (line 41) | pub enum QuantPropagation {
  type QParams (line 51) | pub struct QParams<S> {
  type QParamTensor (line 58) | pub struct QParamTensor {
  function params_shape (line 70) | pub fn params_shape(data_shape: &Shape, level: QuantLevel) -> Shape {
  type QuantizedBytes (line 95) | pub struct QuantizedBytes {
    method new (line 106) | pub fn new<E: bytemuck::CheckedBitPattern + bytemuck::NoUninit>(
    method into_vec_i8 (line 143) | pub fn into_vec_i8(self) -> (Vec<i8>, QParams<Vec<f32>>) {
    method split_i8_values (line 161) | fn split_i8_values(self, num_params: usize) -> (Vec<i8>, Vec<u32>) {
    method split_values_off (line 195) | fn split_values_off(self) -> (Vec<i8>, (Vec<u32>, usize)) {
  function read_bytes_to_i8 (line 233) | fn read_bytes_to_i8(bytes: Bytes) -> Vec<i8> {
  function pack_i8s_to_u32s (line 244) | pub fn pack_i8s_to_u32s(values: Vec<i8>) -> Vec<u32> {
  function unpack_q_to_i8s (line 283) | pub(crate) fn unpack_q_to_i8s<Q: PrimInt>(
  function should_pack_i8s_to_u32 (line 320) | fn should_pack_i8s_to_u32() {
  function should_pack_i8s_to_u32_padded (line 327) | fn should_pack_i8s_to_u32_padded() {
  function should_unpack_u32s_to_i8s (line 336) | fn should_unpack_u32s_to_i8s() {
  function should_unpack_u32s_to_i8s_padded (line 343) | fn should_unpack_u32s_to_i8s_padded() {
  function should_unpack_u32s_to_i8s_arange (line 350) | fn should_unpack_u32s_to_i8s_arange() {
  function should_pack_unpack_quantization_parameters_per_tensor_symmetric (line 374) | fn should_pack_unpack_quantization_parameters_per_tensor_symmetric() {

FILE: crates/burn-std/src/tensor/shape.rs
  type SliceOps (line 12) | pub trait SliceOps: Sized {
    method into_ranges (line 14) | fn into_ranges(self) -> Vec<Range<usize>>;
    method into_slices (line 74) | fn into_slices<S>(self, slices: S) -> Vec<Slice>
    method slice (line 78) | fn slice(self, slices: &[Slice]) -> Result<Self, MetadataError>;
    method into_ranges (line 82) | fn into_ranges(self) -> Vec<Range<usize>> {
    method into_slices (line 86) | fn into_slices<S>(self, slices: S) -> Vec<Slice>
    method slice (line 93) | fn slice(mut self, slices: &[Slice]) -> Result<Self, MetadataError> {
  function test_into_ranges (line 118) | fn test_into_ranges() {
  function test_into_slices (line 126) | fn test_into_slices() {
  function test_shape_as_slice (line 147) | fn test_shape_as_slice() {
  function test_shape_as_mut_slice (line 159) | fn test_shape_as_mut_slice() {
  function test_shape_slice_output_shape_basic (line 177) | fn test_shape_slice_output_shape_basic() {
  function test_shape_slice_output_shape_with_positive_steps (line 189) | fn test_shape_slice_output_shape_with_positive_steps() {
  function test_shape_slice_output_shape_with_negative_steps (line 202) | fn test_shape_slice_output_shape_with_negative_steps() {
  function test_shape_slice_output_shape_mixed_steps (line 214) | fn test_shape_slice_output_shape_mixed_steps() {
  function test_shape_slice_output_shape_partial_dims (line 227) | fn test_shape_slice_output_shape_partial_dims() {
  function test_shape_slice_output_shape_edge_cases (line 238) | fn test_shape_slice_output_shape_edge_cases() {
  function test_shape_slice_output_shape_empty (line 251) | fn test_shape_slice_output_shape_empty() {
  function test_shape_slice_output_shape_uneven_division (line 260) | fn test_shape_slice_output_shape_uneven_division() {

FILE: crates/burn-std/src/tensor/slice.rs
  type SliceArg (line 14) | pub trait SliceArg {
    method into_slices (line 18) | fn into_slices(self, shape: &Shape) -> Vec<Slice>;
    method into_slices (line 22) | fn into_slices(self, shape: &Shape) -> Vec<Slice> {
    method into_slices (line 52) | fn into_slices(self, shape: &Shape) -> Vec<Slice> {
    method into_slices (line 61) | fn into_slices(self, shape: &Shape) -> Vec<Slice> {
    method into_slices (line 70) | fn into_slices(self, shape: &Shape) -> Vec<Slice> {
  type Slice (line 337) | pub struct Slice {
    method new (line 395) | pub const fn new(start: isize, end: Option<isize>, step: isize) -> Self {
    method full (line 401) | pub const fn full() -> Self {
    method index (line 406) | pub fn index(idx: isize) -> Self {
    method into_vec (line 415) | pub fn into_vec(self) -> Vec<isize> {
    method bound_to (line 441) | pub fn bound_to(self, size: usize) -> Self {
    method with_step (line 461) | pub fn with_step(start: isize, end: Option<isize>, step: isize) -> Self {
    method from_range_stepped (line 467) | pub fn from_range_stepped<R: Into<Slice>>(range: R, step: isize) -> Se...
    method step (line 475) | pub fn step(&self) -> isize {
    method range (line 480) | pub fn range(&self, size: usize) -> Range<usize> {
    method to_range (line 493) | pub fn to_range(&self, size: usize) -> Range<usize> {
    method to_range_and_step (line 505) | pub fn to_range_and_step(&self, size: usize) -> (Range<usize>, isize) {
    method is_reversed (line 511) | pub fn is_reversed(&self) -> bool {
    method output_size (line 516) | pub fn output_size(&self, dim_size: usize) -> usize {
    method from (line 547) | fn from(r: Range<I>) -> Self {
    method from (line 557) | fn from(r: RangeInclusive<I>) -> Self {
    method from (line 567) | fn from(r: RangeFrom<I>) -> Self {
    method from (line 577) | fn from(r: RangeTo<I>) -> Self {
    method from (line 587) | fn from(r: RangeToInclusive<I>) -> Self {
    method from (line 597) | fn from(_: RangeFull) -> Self {
    method from (line 607) | fn from(i: usize) -> Self {
    method from (line 613) | fn from(i: isize) -> Self {
    method from (line 619) | fn from(i: i32) -> Self {
    method from (line 625) | fn from(i: i64) -> Self {
  type SliceIter (line 348) | pub struct SliceIter {
  type Item (line 354) | type Item = isize;
  method next (line 356) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 376) | type Item = isize;
  type IntoIter (line 377) | type IntoIter = SliceIter;
  method into_iter (line 379) | fn into_iter(self) -> Self::IntoIter {
  method default (line 388) | fn default() -> Self {
  function convert_signed_index (line 531) | fn convert_signed_index(index: isize, size: usize) -> usize {
  function handle_signed_inclusive_end (line 539) | fn handle_signed_inclusive_end(end: isize) -> Option<isize> {
  method fmt (line 631) | fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
  type Err (line 654) | type Err = crate::ExpressionError;
  method from_str (line 656) | fn from_str(source: &str) -> Result<Self, Self::Err> {
  function test_slice_to_str (line 718) | fn test_slice_to_str() {
  function test_slice_from_str (line 730) | fn test_slice_from_str() {
  function test_slice_output_size (line 777) | fn test_slice_output_size() {
  function test_bound_to (line 789) | fn test_bound_to() {
  function test_slice_iter (line 810) | fn test_slice_iter() {
  function test_unbound_slice_into_vec (line 842) | fn test_unbound_slice_into_vec() {
  function into_slices_should_return_for_all_shape_dims (line 847) | fn into_slices_should_return_for_all_shape_dims() {
  function into_slices_all_dimensions (line 879) | fn into_slices_all_dimensions() {
  function into_slices_supports_empty_dimensions (line 893) | fn into_slices_supports_empty_dimensions() {
  function into_slices_should_match_shape_rank (line 908) | fn into_slices_should_match_shape_rank() {
  function should_support_const_and_full (line 916) | fn should_support_const_and_full() {
  function should_support_default (line 923) | fn should_support_default() {
  function should_support_copy (line 928) | fn should_support_copy() {

FILE: crates/burn-store/benches/download_resnet18.py
  function download_resnet18 (line 23) | def download_resnet18():
  function main (line 70) | def main():

FILE: crates/burn-store/benches/generate_unified_models.py
  function get_temp_dir (line 27) | def get_temp_dir():
  class LargeModel (line 33) | class LargeModel(nn.Module):
    method __init__ (line 35) | def __init__(self):
    method forward (line 47) | def forward(self, x):
  function calculate_model_size (line 52) | def calculate_model_size(model):
  function initialize_weights (line 58) | def initialize_weights(model):
  function save_pytorch_format (line 66) | def save_pytorch_format(model, output_dir):
  function save_safetensors_format (line 82) | def save_safetensors_format(model, output_dir):
  function verify_files (line 100) | def verify_files(pt_path, st_path):
  function main (line 119) | def main():

FILE: crates/burn-store/benches/resnet18_loading.rs
  function main (line 21) | fn main() {
  function resnet18_path (line 58) | fn resnet18_path() -> PathBuf {
  function load_resnet18_metadata (line 79) | fn load_resnet18_metadata(bencher: Bencher) {
  function load_resnet18_materialize_all (line 92) | fn load_resnet18_materialize_all(bencher: Bencher) {
  function load_resnet18_materialize_sequential (line 115) | fn load_resnet18_materialize_sequential(bencher: Bencher) {
  function load_resnet18_largest_tensor (line 148) | fn load_resnet18_largest_tensor(bencher: Bencher) {
  function load_resnet18_memory_profile (line 180) | fn load_resnet18_memory_profile(bencher: Bencher) {

FILE: crates/burn-store/benches/unified_loading.rs
  type NdArrayBackend (line 41) | type NdArrayBackend = burn_ndarray::NdArray<f32>;
  type WgpuBackend (line 44) | type WgpuBackend = burn_wgpu::Wgpu;
  type CudaBackend (line 47) | type CudaBackend = burn_cuda::Cuda<f32, i32>;
  type TchBackend (line 50) | type TchBackend = burn_tch::LibTorch<f32>;
  type MetalBackend (line 53) | type MetalBackend = burn_wgpu::Metal;
  type LargeModel (line 57) | struct LargeModel<B: Backend> {
  function new (line 62) | fn new(device: &B::Device) -> Self {
  function get_model_dir (line 74) | fn get_model_dir() -> PathBuf {
  function generate_burn_formats (line 79) | fn generate_burn_formats(st_path: &Path, bp_path: &Path, mpk_path: &Path) {
  function get_model_paths (line 110) | fn get_model_paths() -> (PathBuf, PathBuf, PathBuf, PathBuf) {
  function check_model_files (line 121) | fn check_model_files() -> Result<(), String> {
  function main (line 145) | fn main() {

FILE: crates/burn-store/benches/unified_saving.rs
  type NdArrayBackend (line 32) | type NdArrayBackend = burn_ndarray::NdArray<f32>;
  type WgpuBackend (line 35) | type WgpuBackend = burn_wgpu::Wgpu;
  type CudaBackend (line 38) | type CudaBackend = burn_cuda::Cuda<f32, i32>;
  type TchBackend (line 41) | type TchBackend = burn_tch::LibTorch<f32>;
  type MetalBackend (line 44) | type MetalBackend = burn_wgpu::Metal;
  type LargeModel (line 48) | struct LargeModel<B: Backend> {
  function new (line 53) | fn new(device: &B::Device) -> Self {
  function get_output_dir (line 65) | fn get_output_dir() -> PathBuf {
  function ensure_output_dir (line 70) | fn ensure_output_dir() -> Result<(), String> {
  function main (line 79) | fn main() {

FILE: crates/burn-store/benches/zero_copy_loading.rs
  type NdArrayBackend (line 58) | type NdArrayBackend = burn_ndarray::NdArray<f32>;
  type WgpuBackend (line 61) | type WgpuBackend = burn_wgpu::Wgpu;
  type CudaBackend (line 64) | type CudaBackend = burn_cuda::Cuda<f32, i32>;
  type TchBackend (line 67) | type TchBackend = burn_tch::LibTorch<f32>;
  type MetalBackend (line 70) | type MetalBackend = burn_wgpu::Metal;
  type LargeModel (line 74) | struct LargeModel<B: Backend> {
  function new (line 79) | fn new(device: &B::Device) -> Self {
  function get_model_dir (line 91) | fn get_model_dir() -> PathBuf {
  function get_burnpack_path (line 96) | fn get_burnpack_path() -> PathBuf {
  function ensure_burnpack_file (line 101) | fn ensure_burnpack_file() {
  function get_static_model_bytes (line 145) | fn get_static_model_bytes() -> &'static [u8] {
  function main (line 154) | fn main() {
  type B (line 306) | type B = NdArray<f32>;
  function verify_storage_is_borrowed (line 310) | fn verify_storage_is_borrowed() {
  function verify_all_layers_borrowed (line 337) | fn verify_all_layers_borrowed() {
  function verify_ops_produce_correct_results (line 373) | fn verify_ops_produce_correct_results() {
  function verify_operations_on_static_data (line 392) | fn verify_operations_on_static_data() {
  function verify_copy_vs_zero_copy_equality (line 441) | fn verify_copy_vs_zero_copy_equality() {
  function file_copy (line 508) | fn file_copy(bencher: Bencher) {
  function file_zero_copy (line 527) | fn file_zero_copy(bencher: Bencher) {
  function static_copy (line 544) | fn static_copy(bencher: Bencher) {
  function static_zero_copy (line 563) | fn static_zero_copy(bencher: Bencher) {

FILE: crates/burn-store/examples/burnpack_inspect.rs
  type SampleModel (line 27) | struct SampleModel<B: Backend> {
  function new (line 34) | fn new(device: &B::Device) -> Self {
  function main (line 43) | fn main() {

FILE: crates/burn-store/examples/half_precision.rs
  type DemoModel (line 19) | struct DemoModel<B: Backend> {
  function new (line 26) | fn new(device: &B::Device) -> Self {
  function main (line 35) | fn main() {

FILE: crates/burn-store/pytorch-tests/tests/backend.rs
  type TestBackend (line 1) | pub type TestBackend = burn_ndarray::NdArray<f32>;

FILE: crates/burn-store/pytorch-tests/tests/batch_norm/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 12) | def forward(self, x):
  function main (line 17) | def main():

FILE: crates/burn-store/pytorch-tests/tests/batch_norm/mod.rs
  type Net (line 8) | pub struct Net<B: Backend> {
  function new (line 13) | pub fn new(device: &B::Device) -> Self {
  function forward (line 20) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  function batch_norm2d (line 35) | fn batch_norm2d() {

FILE: crates/burn-store/pytorch-tests/tests/boolean/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 13) | def forward(self, x):
  function main (line 18) | def main():

FILE: crates/burn-store/pytorch-tests/tests/boolean/mod.rs
  type Net (line 7) | pub struct Net<B: Backend> {
  function init (line 13) | pub fn init(device: &B::Device) -> Self {
  function forward (line 23) | pub fn forward(&self, _x: Tensor<B, 2>) -> Tensor<B, 1, Bool> {
  function boolean (line 39) | fn boolean() {

FILE: crates/burn-store/pytorch-tests/tests/buffer/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 13) | def forward(self, x):
  function main (line 18) | def main():

FILE: crates/burn-store/pytorch-tests/tests/buffer/mod.rs
  type Net (line 7) | pub struct Net<B: Backend> {
  function init (line 13) | pub fn init(device: &B::Device) -> Self {
  function forward (line 20) | pub fn forward(&self, x: Tensor<B, 2>) -> Tensor<B, 2> {
  function buffer (line 35) | fn buffer() {

FILE: crates/burn-store/pytorch-tests/tests/complex_nested/export_weights.py
  class ConvBlock (line 7) | class ConvBlock(nn.Module):
    method __init__ (line 8) | def __init__(self, in_channels, out_channels, kernel_size):
    method forward (line 13) | def forward(self, x):
  class Net (line 18) | class Net(nn.Module):
    method __init__ (line 19) | def __init__(self):
    method forward (line 31) | def forward(self, x):
  function main (line 41) | def main():

FILE: crates/burn-store/pytorch-tests/tests/complex_nested/mod.rs
  type ConvBlock (line 19) | pub struct ConvBlock<B: Backend> {
  type Net (line 25) | pub struct Net<B: Backend> {
  function init (line 33) | pub fn init(device: &B::Device) -> Self {
  function forward (line 57) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 2> {
  function forward (line 71) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  type PartialNet (line 80) | pub struct PartialNet<B: Backend> {
  function init (line 86) | pub fn init(device: &B::Device) -> Self {
  function forward (line 95) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  type PartialWithExtraNet (line 102) | pub struct PartialWithExtraNet<B: Backend> {
  function init (line 109) | pub fn init(device: &B::Device) -> Self {
  function forward (line 122) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  type TestBackend (line 127) | type TestBackend = burn_ndarray::NdArray<f32>;
  function model_test (line 129) | fn model_test(model: Net<TestBackend>, precision: f32) {
  function full_record (line 159) | fn full_record() {
  function full_record_autodiff (line 171) | fn full_record_autodiff() {
  function half_record (line 181) | fn half_record() {
  function partial_model_loading (line 193) | fn partial_model_loading() {
  function extra_field_model_loading (line 217) | fn extra_field_model_loading() {

FILE: crates/burn-store/pytorch-tests/tests/config/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 13) | def forward(self, x):
  class ModelWithBias (line 36) | class ModelWithBias(nn.Module):
    method __init__ (line 37) | def __init__(self):
    method forward (line 41) | def forward(self, x):
  function main (line 47) | def main():

FILE: crates/burn-store/pytorch-tests/tests/config/mod.rs
  type NetConfig (line 8) | struct NetConfig {
  function test_net_config (line 29) | fn test_net_config() {

FILE: crates/burn-store/pytorch-tests/tests/conv1d/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 13) | def forward(self, x):
  function main (line 19) | def main():

FILE: crates/burn-store/pytorch-tests/tests/conv1d/mod.rs
  type Net (line 8) | pub struct Net<B: Backend> {
  function init (line 15) | pub fn init(device: &B::Device) -> Self {
  function forward (line 23) | pub fn forward(&self, x: Tensor<B, 3>) -> Tensor<B, 3> {
  type FT (line 35) | type FT = FloatElem<TestBackend>;
  function conv1d (line 39) | fn conv1d(model: Net<TestBackend>, precision: f32) {
  function conv1d_full_precision (line 75) | fn conv1d_full_precision() {
  function conv1d_half_precision (line 87) | fn conv1d_half_precision() {

FILE: crates/burn-store/pytorch-tests/tests/conv2d/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 13) | def forward(self, x):
  function main (line 19) | def main():

FILE: crates/burn-store/pytorch-tests/tests/conv2d/mod.rs
  type Net (line 8) | pub struct Net<B: Backend> {
  function init (line 15) | pub fn init(device: &B::Device) -> Self {
  function forward (line 25) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  function conv2d (line 41) | fn conv2d(model: Net<TestBackend>, precision: f32) {
  function conv2d_full_precision (line 112) | fn conv2d_full_precision() {
  function conv2d_half_precision (line 124) | fn conv2d_half_precision() {

FILE: crates/burn-store/pytorch-tests/tests/conv_transpose1d/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 13) | def forward(self, x):
  function main (line 19) | def main():

FILE: crates/burn-store/pytorch-tests/tests/conv_transpose1d/mod.rs
  type Net (line 8) | pub struct Net<B: Backend> {
  function init (line 15) | pub fn init(device: &B::Device) -> Self {
  function forward (line 25) | pub fn forward(&self, x: Tensor<B, 3>) -> Tensor<B, 3> {
  function conv_transpose1d (line 41) | fn conv_transpose1d(model: Net<TestBackend>, precision: f32) {
  function conv_transpose1d_full (line 65) | fn conv_transpose1d_full() {
  function conv_transpose1d_half (line 77) | fn conv_transpose1d_half() {

FILE: crates/burn-store/pytorch-tests/tests/conv_transpose2d/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 13) | def forward(self, x):
  function main (line 19) | def main():

FILE: crates/burn-store/pytorch-tests/tests/conv_transpose2d/mod.rs
  type Net (line 8) | pub struct Net<B: Backend> {
  function init (line 15) | pub fn init(device: &B::Device) -> Self {
  function forward (line 25) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  function conv_transpose2d (line 41) | fn conv_transpose2d(model: Net<TestBackend>, precision: f32) {
  function conv_transpose2d_full (line 77) | fn conv_transpose2d_full() {
  function conv_transpose2d_half (line 89) | fn conv_transpose2d_half() {

FILE: crates/burn-store/pytorch-tests/tests/embedding/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 12) | def forward(self, x):
  function main (line 17) | def main():

FILE: crates/burn-store/pytorch-tests/tests/embedding/mod.rs
  type Net (line 8) | pub struct Net<B: Backend> {
  function init (line 14) | pub fn init(device: &B::Device) -> Self {
  function forward (line 20) | pub fn forward(&self, x: Tensor<B, 2, Int>) -> Tensor<B, 3> {
  function embedding (line 33) | fn embedding(model: Net<TestBackend>, precision: f32) {
  function embedding_full_precision (line 64) | fn embedding_full_precision() {
  function embedding_half_precision (line 76) | fn embedding_half_precision() {

FILE: crates/burn-store/pytorch-tests/tests/enum_module/export_weights.py
  class DwsConv (line 5) | class DwsConv(nn.Module):
    method __init__ (line 8) | def __init__(self, in_channels: int, out_channels: int, kernel_size: i...
    method forward (line 15) | def forward(self, x: Tensor) -> Tensor:
  class Model (line 20) | class Model(nn.Module):
    method __init__ (line 21) | def __init__(self, depthwise: bool = False) -> None:
    method forward (line 25) | def forward(self, x: Tensor) -> Tensor:
  function main (line 29) | def main():

FILE: crates/burn-store/pytorch-tests/tests/enum_module/mod.rs
  type Conv (line 9) | pub enum Conv<B: Backend> {
  type DwsConv (line 15) | pub struct DwsConv<B: Backend> {
  type Net (line 21) | pub struct Net<B: Backend> {
  function init_dws_conv (line 27) | pub fn init_dws_conv(device: &B::Device) -> Self {
  function init_conv (line 40) | pub fn init_conv(device: &B::Device) -> Self {
  function forward (line 48) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  type FT (line 65) | type FT = FloatElem<TestBackend>;
  function depthwise_false (line 70) | fn depthwise_false() {
  function depthwise_true (line 134) | fn depthwise_true() {

FILE: crates/burn-store/pytorch-tests/tests/group_norm/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 12) | def forward(self, x):
  function main (line 17) | def main():

FILE: crates/burn-store/pytorch-tests/tests/group_norm/mod.rs
  type Net (line 8) | pub struct Net<B: Backend> {
  function init (line 14) | pub fn init(device: &B::Device) -> Self {
  function forward (line 20) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  function group_norm (line 33) | fn group_norm(model: Net<TestBackend>, precision: f32) {
  function group_norm_full (line 68) | fn group_norm_full() {
  function group_norm_half (line 80) | fn group_norm_half() {

FILE: crates/burn-store/pytorch-tests/tests/integer/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 13) | def forward(self, x):
  function main (line 18) | def main():

FILE: crates/burn-store/pytorch-tests/tests/integer/mod.rs
  type Net (line 7) | pub struct Net<B: Backend> {
  function init (line 13) | pub fn init(device: &B::Device) -> Self {
  function forward (line 23) | pub fn forward(&self, _x: Tensor<B, 2>) -> Tensor<B, 1, Int> {
  function integer (line 36) | fn integer(model: Net<TestBackend>) {
  function integer_full_precision (line 50) | fn integer_full_precision() {
  function integer_half_precision (line 62) | fn integer_half_precision() {

FILE: crates/burn-store/pytorch-tests/tests/key_remap/export_weights.py
  class ConvModule (line 7) | class ConvModule(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 13) | def forward(self, x):
  class Model (line 18) | class Model(nn.Module):
    method __init__ (line 19) | def __init__(self):
    method forward (line 23) | def forward(self, x):
  function main (line 28) | def main():

FILE: crates/burn-store/pytorch-tests/tests/key_remap/mod.rs
  type Net (line 8) | pub struct Net<B: Backend> {
  function init (line 15) | pub fn init(device: &B::Device) -> Self {
  function forward (line 24) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  type FT (line 37) | type FT = FloatElem<TestBackend>;
  function key_remap (line 42) | fn key_remap() {

FILE: crates/burn-store/pytorch-tests/tests/key_remap_chained/export_weights.py
  class ConvBlock (line 7) | class ConvBlock(nn.Module):
    method __init__ (line 8) | def __init__(self, in_channels: int, out_channels: int):
    method forward (line 15) | def forward(self, x: Tensor) -> Tensor:
  class Model (line 19) | class Model(nn.Module):
    method __init__ (line 20) | def __init__(self):
    method forward (line 26) | def forward(self, x: Tensor) -> Tensor:
  function main (line 34) | def main():

FILE: crates/burn-store/pytorch-tests/tests/key_remap_chained/mod.rs
  type ForwardModule (line 13) | pub trait ForwardModule<B: Backend> {
    method forward (line 14) | fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4>;
  type ConvBlock (line 19) | pub struct ConvBlock<B: Backend> {
  function forward (line 25) | fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
  function new (line 32) | pub fn new(in_channels: usize, out_channels: usize, device: &Device<B>) ...
  type ModuleBlock (line 44) | pub struct ModuleBlock<B: Backend, M> {
  function forward (line 50) | pub fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
  function new (line 60) | pub fn new(device: &Device<B>) -> Self {
  type Model (line 71) | pub struct Model<B: Backend, M> {
  function new (line 78) | pub fn new(device: &Device<B>) -> Self {
  function forward (line 89) | pub fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
  type FT (line 102) | type FT = FloatElem<TestBackend>;
  function key_remap_chained_missing_pattern (line 108) | fn key_remap_chained_missing_pattern() {
  function key_remap_chained (line 124) | fn key_remap_chained() {

FILE: crates/burn-store/pytorch-tests/tests/layer_norm/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 12) | def forward(self, x):
  function main (line 17) | def main():

FILE: crates/burn-store/pytorch-tests/tests/layer_norm/mod.rs
  type Net (line 8) | pub struct Net<B: Backend> {
  function init (line 14) | pub fn init(device: &B::Device) -> Self {
  function forward (line 20) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  type FT (line 31) | type FT = FloatElem<TestBackend>;
  function layer_norm (line 35) | fn layer_norm(model: Net<TestBackend>, precision: f32) {
  function layer_norm_full (line 62) | fn layer_norm_full() {
  function layer_norm_half (line 73) | fn layer_norm_half() {

FILE: crates/burn-store/pytorch-tests/tests/linear/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 13) | def forward(self, x):
  class ModelWithBias (line 21) | class ModelWithBias(nn.Module):
    method __init__ (line 22) | def __init__(self):
    method forward (line 26) | def forward(self, x):
  function main (line 32) | def main():

FILE: crates/burn-store/pytorch-tests/tests/linear/mod.rs
  type Net (line 8) | pub struct Net<B: Backend> {
  function init (line 16) | pub fn init(device: &B::Device) -> Self {
  function forward (line 25) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  type NetWithBias (line 34) | struct NetWithBias<B: Backend> {
  function init (line 40) | pub fn init(device: &B::Device) -> Self {
  function forward (line 47) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  type FT (line 58) | type FT = FloatElem<TestBackend>;
  function linear_test (line 62) | fn linear_test(model: Net<TestBackend>, precision: f32) {
  function linear_full_precision (line 93) | fn linear_full_precision() {
  function linear_half_precision (line 105) | fn linear_half_precision() {
  function linear_with_bias (line 117) | fn linear_with_bias() {

FILE: crates/burn-store/pytorch-tests/tests/missing_module_field/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 12) | def forward(self, x):
  function main (line 17) | def main():

FILE: crates/burn-store/pytorch-tests/tests/missing_module_field/mod.rs
  type Net (line 5) | pub struct Net<B: Backend> {
  function init (line 19) | pub fn init(device: &B::Device) -> Self {
  function should_fail_if_struct_field_is_missing (line 28) | fn should_fail_if_struct_field_is_missing() {

FILE: crates/burn-store/pytorch-tests/tests/non_contiguous_indexes/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 21) | def forward(self, x):
  function main (line 25) | def main():

FILE: crates/burn-store/pytorch-tests/tests/non_contiguous_indexes/mod.rs
  type Net (line 11) | pub struct Net<B: Backend> {
  function init (line 17) | pub fn init(device: &B::Device) -> Self {
  function forward (line 32) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  type FT (line 43) | type FT = FloatElem<TestBackend>;
  function non_contiguous_indexes (line 48) | fn non_contiguous_indexes() {

FILE: crates/burn-store/pytorch-tests/tests/top_level_key/export_weights.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 12) | def forward(self, x):
  function main (line 17) | def main():

FILE: crates/burn-store/pytorch-tests/tests/top_level_key/mod.rs
  type Net (line 5) | pub struct Net<B: Backend> {
  function init (line 19) | pub fn init(device: &B::Device) -> Self {
  function should_fail_if_not_found (line 28) | fn should_fail_if_not_found() {
  function should_load (line 38) | fn should_load() {

FILE: crates/burn-store/safetensors-tests/tests/backend.rs
  type TestBackend (line 1) | pub type TestBackend = burn_ndarray::NdArray<f32>;

FILE: crates/burn-store/safetensors-tests/tests/multi_layer/mod.rs
  type Net (line 11) | pub struct Net<B: Backend> {
  function new (line 19) | pub fn new(device: &B::Device) -> Self {
  function forward (line 31) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 2> {
  function multi_layer_model (line 51) | fn multi_layer_model() {

FILE: crates/burn-store/safetensors-tests/tests/multi_layer/multi_layer.py
  class Model (line 9) | class Model(nn.Module):
    method __init__ (line 10) | def __init__(self):
    method forward (line 17) | def forward(self, x):
  function main (line 26) | def main():

FILE: crates/burn-store/src/adapter.rs
  constant LINEAR (line 26) | pub const LINEAR: &str = "Struct:Linear";
  constant BATCH_NORM (line 27) | pub const BATCH_NORM: &str = "Struct:BatchNorm";
  constant LAYER_NORM (line 28) | pub const LAYER_NORM: &str = "Struct:LayerNorm";
  constant GROUP_NORM (line 29) | pub const GROUP_NORM: &str = "Struct:GroupNorm";
  constant EMBEDDING (line 30) | pub const EMBEDDING: &str = "Struct:Embedding";
  constant CONV1D (line 31) | pub const CONV1D: &str = "Struct:Conv1d";
  constant CONV2D (line 32) | pub const CONV2D: &str = "Struct:Conv2d";
  constant CONV3D (line 33) | pub const CONV3D: &str = "Struct:Conv3d";
  constant CONV_TRANSPOSE1D (line 34) | pub const CONV_TRANSPOSE1D: &str = "Struct:ConvTranspose1d";
  constant CONV_TRANSPOSE2D (line 35) | pub const CONV_TRANSPOSE2D: &str = "Struct:ConvTranspose2d";
  constant CONV_TRANSPOSE3D (line 36) | pub const CONV_TRANSPOSE3D: &str = "Struct:ConvTranspose3d";
  constant DEFORM_CONV2D (line 37) | pub const DEFORM_CONV2D: &str = "Struct:DeformConv2d";
  constant INSTANCE_NORM (line 38) | pub const INSTANCE_NORM: &str = "Struct:InstanceNorm";
  constant RMS_NORM (line 39) | pub const RMS_NORM: &str = "Struct:RmsNorm";
  constant PRELU (line 40) | pub const PRELU: &str = "Struct:PRelu";
  type ModuleAdapter (line 44) | pub trait ModuleAdapter: Send + Sync {
    method adapt (line 46) | fn adapt(&self, snapshot: &TensorSnapshot) -> TensorSnapshot;
    method get_alternative_param_name (line 60) | fn get_alternative_param_name(
    method clone_box (line 69) | fn clone_box(&self) -> Box<dyn ModuleAdapter>;
    method chain (line 80) | fn chain<A>(self, next: A) -> ChainAdapter
    method adapt (line 119) | fn adapt(&self, snapshot: &TensorSnapshot) -> TensorSnapshot {
    method get_alternative_param_name (line 124) | fn get_alternative_param_name(&self, param_name: &str, container_type:...
    method clone_box (line 138) | fn clone_box(&self) -> Box<dyn ModuleAdapter> {
    method adapt (line 148) | fn adapt(&self, snapshot: &TensorSnapshot) -> TensorSnapshot {
    method clone_box (line 152) | fn clone_box(&self) -> Box<dyn ModuleAdapter> {
    method adapt (line 278) | fn adapt(&self, snapshot: &TensorSnapshot) -> TensorSnapshot {
    method clone_box (line 307) | fn clone_box(&self) -> Box<dyn ModuleAdapter> {
    method adapt (line 321) | fn adapt(&self, snapshot: &TensorSnapshot) -> TensorSnapshot {
    method get_alternative_param_name (line 325) | fn get_alternative_param_name(&self, param_name: &str, container_type:...
    method clone_box (line 334) | fn clone_box(&self) -> Box<dyn ModuleAdapter> {
    method adapt (line 348) | fn adapt(&self, snapshot: &TensorSnapshot) -> TensorSnapshot {
    method get_alternative_param_name (line 352) | fn get_alternative_param_name(&self, param_name: &str, container_type:...
    method clone_box (line 361) | fn clone_box(&self) -> Box<dyn ModuleAdapter> {
    method adapt (line 678) | fn adapt(&self, snapshot: &TensorSnapshot) -> TensorSnapshot {
    method get_alternative_param_name (line 706) | fn get_alternative_param_name(
    method clone_box (line 714) | fn clone_box(&self) -> Box<dyn ModuleAdapter> {
    method adapt (line 727) | fn adapt(&self, snapshot: &TensorSnapshot) -> TensorSnapshot {
    method get_alternative_param_name (line 738) | fn get_alternative_param_name(
    method clone_box (line 751) | fn clone_box(&self) -> Box<dyn ModuleAdapter> {
  method clone (line 90) | fn clone(&self) -> Self {
  type ChainAdapter (line 99) | pub struct ChainAdapter {
    method new (line 106) | pub fn new<A, B>(first: A, second: B) -> Self
  type IdentityAdapter (line 145) | pub struct IdentityAdapter;
  function default_half_precision_modules (line 163) | fn default_half_precision_modules() -> HashSet<String> {
  type HalfPrecisionAdapter (line 219) | pub struct HalfPrecisionAdapter {
    method new (line 225) | pub fn new() -> Self {
    method with_module (line 236) | pub fn with_module(mut self, module_type: impl Into<String>) -> Self {
    method without_module (line 247) | pub fn without_module(mut self, module_type: impl Into<String>) -> Self {
    method should_convert (line 264) | fn should_convert(&self, snapshot: &TensorSnapshot) -> bool {
  method default (line 272) | fn default() -> Self {
  type PyTorchToBurnAdapter (line 318) | pub struct PyTorchToBurnAdapter;
  type BurnToPyTorchAdapter (line 345) | pub struct BurnToPyTorchAdapter;
  type PyTorchConversionDirection (line 368) | enum PyTorchConversionDirection {
  function is_normalization_layer (line 374) | fn is_normalization_layer(container_type: &str) -> bool {
  function pytorch_norm_param_to_burn (line 382) | fn pytorch_norm_param_to_burn(param_name: &str) -> Option<&'static str> {
  function burn_norm_param_to_pytorch (line 391) | fn burn_norm_param_to_pytorch(param_name: &str) -> Option<&'static str> {
  function adapt_pytorch_tensor (line 400) | fn adapt_pytorch_tensor(
  function get_path_and_param (line 437) | fn get_path_and_param(snapshot: &TensorSnapshot) -> Option<(&[String], &...
  function rename_parameter (line 444) | fn rename_parameter(
  function transpose_2d_tensor (line 463) | fn transpose_2d_tensor(snapshot: &TensorSnapshot) -> TensorSnapshot {
  function transpose_tensor_data (line 489) | fn transpose_tensor_data(data: TensorData) -> TensorData {
  function test_module_names_match_burn_nn (line 527) | fn test_module_names_match_burn_nn() {
  function create_test_snapshot (line 555) | fn create_test_snapshot(path: &str, shape: Shape, container_type: &str) ...
  function test_pytorch_to_burn_linear_weight (line 571) | fn test_pytorch_to_burn_linear_weight() {
  function test_pytorch_to_burn_norm_params (line 586) | fn test_pytorch_to_burn_norm_params() {
  function test_burn_to_pytorch_linear_weight (line 601) | fn test_burn_to_pytorch_linear_weight() {
  function test_burn_to_pytorch_norm_params (line 611) | fn test_burn_to_pytorch_norm_params() {
  function test_transpose_different_dtypes (line 626) | fn test_transpose_different_dtypes() {
  function test_no_container_info (line 652) | fn test_no_container_info() {
  type RenameParamAdapter (line 671) | struct RenameParamAdapter {
  type AltNameAdapter (line 720) | struct AltNameAdapter {
  function test_chain_adapter_pipes_adapt (line 757) | fn test_chain_adapter_pipes_adapt() {
  function test_chain_adapter_alternative_name_pipes_and_fallbacks (line 782) | fn test_chain_adapter_alternative_name_pipes_and_fallbacks() {
  function test_half_precision_f32_to_f16 (line 849) | fn test_half_precision_f32_to_f16() {
  function test_half_precision_f16_to_f32 (line 862) | fn test_half_precision_f16_to_f32() {
  function test_half_precision_skips_batch_norm (line 883) | fn test_half_precision_skips_batch_norm() {
  function test_half_precision_converts_default_modules (line 893) | fn test_half_precision_converts_default_modules() {
  function test_half_precision_without_module (line 923) | fn test_half_precision_without_module() {
  function test_half_precision_with_module (line 936) | fn test_half_precision_with_module() {
  function test_half_precision_with_qualified_name (line 945) | fn test_half_precision_with_qualified_name() {
  function test_half_precision_chain (line 953) | fn test_half_precision_chain() {
  function test_half_precision_skips_no_container (line 965) | fn test_half_precision_skips_no_container() {
  function test_half_precision_skips_non_float (line 976) | fn test_half_precision_skips_non_float() {
  function test_half_precision_default_module_count (line 997) | fn test_half_precision_default_module_count() {
  function test_half_precision_without_module_qualified (line 1005) | fn test_half_precision_without_module_qualified() {
  function test_half_precision_with_module_batch_norm_opt_in (line 1013) | fn test_half_precision_with_module_batch_norm_opt_in() {

FILE: crates/burn-store/src/applier.rs
  type Applier (line 18) | pub struct Applier<B: Backend> {
  function new (line 54) | pub fn new(
  function current_path (line 81) | fn current_path(&self) -> String {
  function current_module_type (line 86) | fn current_module_type(&self) -> Option<&str> {
  function should_apply (line 95) | fn should_apply(&self) -> bool {
  function into_result (line 103) | pub fn into_result(self) -> ApplyResult {
  function apply_tensor (line 155) | fn apply_tensor<const D: usize, K>(
  function enter_module (line 245) | fn enter_module(&mut self, name: &str, container_type: &str) {
  function exit_module (line 256) | fn exit_module(&mut self, _name: &str, container_type: &str) {
  function map_float (line 265) | fn map_float<const D: usize>(&mut self, param: Param<Tensor<B, D>>) -> P...
  function map_int (line 283) | fn map_int<const D: usize>(
  function map_bool (line 304) | fn map_bool<const D: usize>(
  type TestBackend (line 332) | type TestBackend = burn_ndarray::NdArray;
  function root_level_parameters (line 335) | fn root_level_parameters() {
  function dtype_preservation_f64 (line 400) | fn dtype_preservation_f64() {
  function dtype_preservation_f32 (line 456) | fn dtype_preservation_f32() {
  function dtype_preservation_f16_snapshot (line 501) | fn dtype_preservation_f16_snapshot() {
  function dtype_preservation_bf16_snapshot (line 559) | fn dtype_preservation_bf16_snapshot() {

FILE: crates/burn-store/src/apply_result.rs
  type ApplyError (line 11) | pub enum ApplyError {
    method fmt (line 47) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type ApplyResult (line 85) | pub struct ApplyResult {
    method strip_enum_variant (line 102) | fn strip_enum_variant(path: &str) -> Option<String> {
    method find_similar_paths (line 130) | fn find_similar_paths(&self, missing_path: &str, max_suggestions: usiz...
    method is_success (line 167) | pub fn is_success(&self) -> bool {
    method fmt (line 173) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method fmt (line 180) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

FILE: crates/burn-store/src/burnpack/base.rs
  constant MAGIC_NUMBER (line 14) | pub const MAGIC_NUMBER: u32 = 0x4255524E;
  constant FORMAT_VERSION (line 17) | pub const FORMAT_VERSION: u16 = 0x0001;
  constant MAGIC_SIZE (line 20) | pub const MAGIC_SIZE: usize = 4;
  constant VERSION_SIZE (line 23) | pub const VERSION_SIZE: usize = 2;
  constant METADATA_SIZE_FIELD_SIZE (line 26) | pub const METADATA_SIZE_FIELD_SIZE: usize = 4;
  constant HEADER_SIZE (line 29) | pub const HEADER_SIZE: usize = MAGIC_SIZE + VERSION_SIZE + METADATA_SIZE...
  constant TENSOR_ALIGNMENT (line 47) | pub const TENSOR_ALIGNMENT: u64 = 256;
  function aligned_data_section_start (line 57) | pub fn aligned_data_section_start(metadata_size: usize) -> usize {
  constant MAX_METADATA_SIZE (line 68) | pub const MAX_METADATA_SIZE: u32 = 100 * 1024 * 1024;
  constant MAX_TENSOR_SIZE (line 75) | pub const MAX_TENSOR_SIZE: usize = 2 * 1024 * 1024 * 1024;
  constant MAX_TENSOR_SIZE (line 77) | pub const MAX_TENSOR_SIZE: usize = 10 * 1024 * 1024 * 1024;
  constant MAX_TENSOR_COUNT (line 81) | pub const MAX_TENSOR_COUNT: usize = 100_000;
  constant MAX_CBOR_RECURSION_DEPTH (line 85) | pub const MAX_CBOR_RECURSION_DEPTH: usize = 128;
  constant MAX_FILE_SIZE (line 91) | pub const MAX_FILE_SIZE: u64 = 100 * 1024 * 1024 * 1024;
  function magic_range (line 94) | pub const fn magic_range() -> core::ops::Range<usize> {
  function version_range (line 101) | pub const fn version_range() -> core::ops::Range<usize> {
  function metadata_size_range (line 108) | pub const fn metadata_size_range() -> core::ops::Range<usize> {
  constant _ (line 115) | const _: () = assert!(MAGIC_SIZE + VERSION_SIZE + METADATA_SIZE_FIELD_SI...
  type BurnpackHeader (line 119) | pub struct BurnpackHeader {
    method new (line 131) | pub fn new(metadata_size: u32) -> Self {
    method into_bytes (line 140) | pub fn into_bytes(self) -> [u8; HEADER_SIZE] {
    method from_bytes (line 149) | pub fn from_bytes(bytes: &[u8]) -> Result<Self, BurnpackError> {
  type BurnpackMetadata (line 172) | pub struct BurnpackMetadata {
  type TensorDescriptor (line 182) | pub struct TensorDescriptor {
  type BurnpackError (line 197) | pub enum BurnpackError {
    method fmt (line 210) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

FILE: crates/burn-store/src/burnpack/reader.rs
  type StorageBackend (line 27) | pub(crate) enum StorageBackend {
    method read_into (line 57) | pub(crate) fn read_into(&self, bytes: &mut [u8], offset: usize) -> Res...
    method as_bytes (line 100) | pub(crate) fn as_bytes(&self) -> Result<&[u8], BurnpackError> {
    method slice_bytes (line 118) | pub(crate) fn slice_bytes(&self, start: usize, end: usize) -> Result<B...
  type BurnpackReader (line 156) | pub struct BurnpackReader {
    method from_bytes (line 167) | pub fn from_bytes(bytes: Bytes) -> Result<Self, BurnpackError> {
    method from_file_mmap (line 265) | pub(crate) fn from_file_mmap<P: AsRef<Path>>(path: P) -> Result<Self, ...
    method from_file (line 388) | pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self, BurnpackErro...
    method from_file_buffered (line 405) | pub(crate) fn from_file_buffered<P: AsRef<Path>>(path: P) -> Result<Se...
    method get_snapshots (line 518) | pub fn get_snapshots(&self) -> Result<Vec<TensorSnapshot>, BurnpackErr...
    method get_snapshots_zero_copy (line 530) | pub fn get_snapshots_zero_copy(
    method get_snapshots_internal (line 538) | fn get_snapshots_internal(
    method get_tensor_snapshot (line 685) | pub(crate) fn get_tensor_snapshot(&self, name: &str) -> Result<TensorS...
    method tensor_names (line 695) | pub(crate) fn tensor_names(&self) -> Vec<&str> {
    method metadata (line 705) | pub(crate) fn metadata(&self) -> &BurnpackMetadata {
    method get_tensor_data (line 711) | pub(crate) fn get_tensor_data(&self, name: &str) -> Result<Vec<u8>, Bu...

FILE: crates/burn-store/src/burnpack/store.rs
  type StoreMode (line 21) | enum StoreMode {
  type BurnpackStore (line 28) | pub struct BurnpackStore {
    method default_metadata (line 73) | pub fn default_metadata() -> BTreeMap<String, String> {
    method from_file (line 100) | pub fn from_file<P: AsRef<std::path::Path>>(path: P) -> Self {
    method from_bytes (line 122) | pub fn from_bytes(bytes: Option<Bytes>) -> Self {
    method from_static (line 155) | pub fn from_static(data: &'static [u8]) -> Self {
    method metadata (line 185) | pub fn metadata(mut self, key: impl Into<String>, value: impl Into<Str...
    method clear_metadata (line 194) | pub fn clear_metadata(mut self) -> Self {
    method allow_partial (line 205) | pub fn allow_partial(mut self, allow: bool) -> Self {
    method validate (line 217) | pub fn validate(mut self, validate: bool) -> Self {
    method overwrite (line 228) | pub fn overwrite(mut self, overwrite: bool) -> Self {
    method zero_copy (line 244) | pub fn zero_copy(mut self, enable: bool) -> Self {
    method auto_extension (line 270) | pub fn auto_extension(mut self, enable: bool) -> Self {
    method with_from_adapter (line 276) | pub fn with_from_adapter(mut self, adapter: impl ModuleAdapter + 'stat...
    method with_to_adapter (line 282) | pub fn with_to_adapter(mut self, adapter: impl ModuleAdapter + 'static...
    method with_filter (line 288) | pub fn with_filter(mut self, filter: PathFilter) -> Self {
    method with_regex (line 295) | pub fn with_regex(mut self, pattern: &str) -> Self {
    method with_full_path (line 302) | pub fn with_full_path(mut self, path: impl Into<String>) -> Self {
    method match_all (line 309) | pub fn match_all(mut self) -> Self {
    method remap (line 316) | pub fn remap(mut self, remapper: KeyRemapper) -> Self {
    method with_remap_pattern (line 323) | pub fn with_remap_pattern<S1, S2>(mut self, from: S1, to: S2) -> Self
    method filter (line 336) | pub fn filter(mut self, filter: PathFilter) -> Self {
    method get_bytes (line 342) | pub fn get_bytes(&self) -> Result<Bytes, BurnpackError> {
    method process_path (line 355) | fn process_path(&self, path: &std::path::Path) -> PathBuf {
    method ensure_reader (line 373) | fn ensure_reader(&mut self) -> Result<&BurnpackReader, BurnpackError> {
    method ensure_snapshots_cache (line 509) | fn ensure_snapshots_cache(&mut self) -> Result<(), BurnpackError> {
  type Error (line 396) | type Error = BurnpackError;
  method collect_from (line 398) | fn collect_from<B: Backend, M: ModuleSnapshot<B>>(
  method apply_to (line 453) | fn apply_to<B: Backend, M: ModuleSnapshot<B>>(
  method get_snapshot (line 489) | fn get_snapshot(&mut self, name: &str) -> Result<Option<&TensorSnapshot>...
  method get_all_snapshots (line 495) | fn get_all_snapshots(&mut self) -> Result<&BTreeMap<String, TensorSnapsh...
  method keys (line 501) | fn keys(&mut self) -> Result<Vec<String>, Self::Error> {

FILE: crates/burn-store/src/burnpack/tests/alignment.rs
  function test_aligned_data_section_start_is_always_aligned (line 18) | fn test_aligned_data_section_start_is_always_aligned() {
  function test_data_section_alignment (line 35) | fn test_data_section_alignment() {
  function test_first_tensor_absolute_position_aligned (line 72) | fn test_first_tensor_absolute_position_aligned() {
  function test_all_tensors_absolute_positions_aligned (line 105) | fn test_all_tensors_absolute_positions_aligned() {
  function test_alignment_with_minimal_padding (line 154) | fn test_alignment_with_minimal_padding() {
  function test_padding_bytes_are_zeros (line 169) | fn test_padding_bytes_are_zeros() {
  function test_alignment_covers_all_primitive_types (line 203) | fn test_alignment_covers_all_primitive_types() {
  function test_aligned_tensor_data_readable (line 229) | fn test_aligned_tensor_data_readable() {
  function test_aligned_f64_tensor_data_readable (line 269) | fn test_aligned_f64_tensor_data_readable() {
  function test_round_trip_maintains_alignment (line 310) | fn test_round_trip_maintains_alignment() {
  function test_tensor_relative_offsets_are_aligned (line 344) | fn test_tensor_relative_offsets_are_aligned() {
  function test_file_io_preserves_alignment (line 386) | fn test_file_io_preserves_alignment() {

FILE: crates/burn-store/src/burnpack/tests/edge_cases.rs
  function test_maximum_metadata_size (line 11) | fn test_maximum_metadata_size() {
  function test_zero_size_tensor_shapes (line 35) | fn test_zero_size_tensor_shapes() {
  function test_extremely_long_tensor_names (line 67) | fn test_extremely_long_tensor_names() {
  function test_unicode_in_names_and_metadata (line 87) | fn test_unicode_in_names_and_metadata() {
  function test_all_supported_dtypes (line 133) | fn test_all_supported_dtypes() {
  function test_special_float_values (line 215) | fn test_special_float_values() {
  function test_metadata_with_empty_values (line 248) | fn test_metadata_with_empty_values() {
  function test_single_byte_tensor (line 264) | fn test_single_byte_tensor() {
  function test_high_dimensional_tensor (line 282) | fn test_high_dimensional_tensor() {
  function test_metadata_key_collision (line 303) | fn test_metadata_key_collision() {
  function test_tensor_name_with_path_separators (line 320) | fn test_tensor_name_with_path_separators() {

FILE: crates/burn-store/src/burnpack/tests/header.rs
  function test_header_serialization (line 4) | fn test_header_serialization() {
  function test_header_invalid_magic (line 24) | fn test_header_invalid_magic() {
  function test_header_insufficient_bytes (line 37) | fn test_header_insufficient_bytes() {
  function test_version_compatibility (line 48) | fn test_version_compatibility() {

FILE: crates/burn-store/src/burnpack/tests/helpers.rs
  function create_test_snapshot (line 7) | pub fn create_test_snapshot(

FILE: crates/burn-store/src/burnpack/tests/reader.rs
  function test_reader_from_bytes_empty (line 14) | fn test_reader_from_bytes_empty() {
  function test_reader_from_bytes_with_data (line 27) | fn test_reader_from_bytes_with_data() {
  function test_reader_invalid_magic_number (line 55) | fn test_reader_invalid_magic_number() {
  function test_reader_invalid_version (line 65) | fn test_reader_invalid_version() {
  function test_reader_header_too_short (line 77) | fn test_reader_header_too_short() {
  function test_reader_metadata_truncated (line 85) | fn test_reader_metadata_truncated() {
  function test_reader_get_tensor_not_found (line 98) | fn test_reader_get_tensor_not_found() {
  function test_reader_get_tensor_snapshot (line 108) | fn test_reader_get_tensor_snapshot() {
  function test_reader_multiple_tensors (line 136) | fn test_reader_multiple_tensors() {
  function test_reader_lazy_loading (line 165) | fn test_reader_lazy_loading() {
  function test_reader_all_dtypes (line 190) | fn test_reader_all_dtypes() {
  function test_reader_empty_tensor (line 231) | fn test_reader_empty_tensor() {
  function test_reader_from_file (line 252) | fn test_reader_from_file() {
  function test_reader_from_file_mmap (line 284) | fn test_reader_from_file_mmap() {
  function test_reader_from_file_buffered (line 313) | fn test_reader_from_file_buffered() {
  function test_reader_metadata_access (line 338) | fn test_reader_metadata_access() {
  function test_reader_tensor_iteration (line 367) | fn test_reader_tensor_iteration() {
  function test_reader_corrupt_metadata (line 408) | fn test_reader_corrupt_metadata() {
  function test_reader_data_offsets_validation (line 427) | fn test_reader_data_offsets_validation() {
  function test_reader_out_of_bounds_error (line 458) | fn test_reader_out_of_bounds_error() {
  function test_reader_offset_overflow_error (line 477) | fn test_reader_offset_overflow_error() {
  function test_reader_corrupted_shape_returns_error (line 495) | fn test_reader_corrupted_shape_returns_error() {
  function test_reader_corrupted_offsets_returns_error (line 551) | fn test_reader_corrupted_offsets_returns_error() {
  function test_reader_inverted_offsets_returns_error (line 641) | fn test_reader_inverted_offsets_returns_error() {
  function test_reader_truncated_file_from_bytes (line 682) | fn test_reader_truncated_file_from_bytes() {
  function test_reader_truncated_file_from_file (line 712) | fn test_reader_truncated_file_from_file() {
  function test_reader_file_size_exactly_correct (line 752) | fn test_reader_file_size_exactly_correct() {

FILE: crates/burn-store/src/burnpack/tests/round_trip.rs
  function round_trip_test (line 9) | fn round_trip_test<F>(setup: F)
  function test_round_trip_empty (line 54) | fn test_round_trip_empty() {
  function test_round_trip_metadata_only (line 61) | fn test_round_trip_metadata_only() {
  function test_round_trip_f32 (line 70) | fn test_round_trip_f32() {
  function test_round_trip_f64 (line 85) | fn test_round_trip_f64() {
  function test_round_trip_i32 (line 100) | fn test_round_trip_i32() {
  function test_round_trip_i64 (line 115) | fn test_round_trip_i64() {
  function test_round_trip_u32 (line 130) | fn test_round_trip_u32() {
  function test_round_trip_u64 (line 145) | fn test_round_trip_u64() {
  function test_round_trip_u8 (line 160) | fn test_round_trip_u8() {
  function test_round_trip_bool (line 174) | fn test_round_trip_bool() {
  function test_round_trip_mixed_dtypes (line 188) | fn test_round_trip_mixed_dtypes() {
  function test_round_trip_multidimensional (line 224) | fn test_round_trip_multidimensional() {
  function test_round_trip_with_metadata_and_tensors (line 262) | fn test_round_trip_with_metadata_and_tensors() {
  function test_round_trip_special_values (line 296) | fn test_round_trip_special_values() {
  function test_round_trip_large_tensors (line 341) | fn test_round_trip_large_tensors() {
  function test_round_trip_file_io (line 359) | fn test_round_trip_file_io() {
  function test_round_trip_empty_shapes (line 415) | fn test_round_trip_empty_shapes() {
  function test_param_id_persistence (line 440) | fn test_param_id_persistence() {
  function test_param_id_backward_compatibility (line 479) | fn test_param_id_backward_compatibility() {
  function test_multiple_tensors_preserve_distinct_param_ids (line 545) | fn test_multiple_tensors_preserve_distinct_param_ids() {

FILE: crates/burn-store/src/burnpack/tests/store.rs
  type TestBackend (line 11) | type TestBackend = burn_ndarray::NdArray;
  type TestModule (line 14) | struct TestModule<B: Backend> {
  type NestedModule (line 21) | struct NestedModule<B: Backend> {
  function new (line 27) | fn new(device: &B::Device) -> Self {
  function new_zeros (line 38) | fn new_zeros(device: &B::Device) -> Self {
  function new_uninitialized (line 49) | fn new_uninitialized(device: &B::Device) -> Self {
  function test_store_from_bytes_round_trip (line 92) | fn test_store_from_bytes_round_trip() {
  function test_store_with_metadata (line 118) | fn test_store_with_metadata() {
  function test_store_with_path_filter (line 142) | fn test_store_with_path_filter() {
  function test_store_with_key_remapping (line 178) | fn test_store_with_key_remapping() {
  function test_store_allow_partial (line 208) | fn test_store_allow_partial() {
  function test_store_match_all (line 236) | fn test_store_match_all() {
  function test_store_with_full_path (line 258) | fn test_store_with_full_path() {
  function test_store_chain_multiple_patterns (line 282) | fn test_store_chain_multiple_patterns() {
  function test_store_with_remap_pattern (line 307) | fn test_store_with_remap_pattern() {
  function test_store_default_metadata (line 330) | fn test_store_default_metadata() {
  function test_store_default_metadata_with_custom (line 350) | fn test_store_default_metadata_with_custom() {
  function test_store_clear_metadata (line 370) | fn test_store_clear_metadata() {
  function test_store_validate_enabled (line 388) | fn test_store_validate_enabled() {
  function test_store_validate_disabled (line 407) | fn test_store_validate_disabled() {
  function test_store_allow_partial_missing_tensors (line 426) | fn test_store_allow_partial_missing_tensors() {
  function test_store_file_round_trip (line 456) | fn test_store_file_round_trip() {
  function test_store_overwrite_protection (line 489) | fn test_store_overwrite_protection() {
  function test_store_overwrite_with_metadata (line 528) | fn test_store_overwrite_with_metadata() {
  function test_store_auto_extension_default (line 559) | fn test_store_auto_extension_default() {
  function test_store_auto_extension_with_existing_extension (line 587) | fn test_store_auto_extension_with_existing_extension() {
  function test_store_auto_extension_with_custom_extension (line 615) | fn test_store_auto_extension_with_custom_extension() {
  function test_store_auto_extension_disabled (line 643) | fn test_store_auto_extension_disabled() {
  function test_partial_loading_preserves_lazy_initialization (line 671) | fn test_partial_loading_preserves_lazy_initialization() {
  type ForwardTestModel (line 762) | struct ForwardTestModel<B: Backend> {
  function forward (line 769) | fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2> {
  type ForwardTestModelConfig (line 777) | struct ForwardTestModelConfig {
    method init (line 784) | fn init<B: Backend>(&self, device: &B::Device) -> ForwardTestModel<B> {
  function test_forward_pass_preservation_after_save_load (line 798) | fn test_forward_pass_preservation_after_save_load() {
  function test_store_get_all_snapshots (line 860) | fn test_store_get_all_snapshots() {
  function test_store_get_snapshot_existing (line 884) | fn test_store_get_snapshot_existing() {
  function test_store_get_snapshot_nested (line 909) | fn test_store_get_snapshot_nested() {
  function test_store_get_snapshot_not_found (line 929) | fn test_store_get_snapshot_not_found() {
  function test_store_keys (line 947) | fn test_store_keys() {
  function test_store_get_all_snapshots_from_file (line 970) | fn test_store_get_all_snapshots_from_file() {
  function test_store_caching_behavior (line 996) | fn test_store_caching_behavior() {
  function test_store_cache_invalidation_on_save (line 1022) | fn test_store_cache_invalidation_on_save() {
  function test_store_quantized_module_round_trip (line 1065) | fn test_store_quantized_module_round_trip() {
  function test_store_half_precision_round_trip (line 1128) | fn test_store_half_precision_round_trip() {
  function test_store_half_precision_batch_norm_excluded (line 1185) | fn test_store_half_precision_batch_norm_excluded() {
  function test_store_half_precision_without_module (line 1231) | fn test_store_half_precision_without_module() {
  function test_store_half_precision_chained_with_pytorch (line 1277) | fn test_store_half_precision_chained_with_pytorch() {
  function test_store_quantized_module_block_level (line 1318) | fn test_store_quantized_module_block_level() {

FILE: crates/burn-store/src/burnpack/tests/writer.rs
  function test_writer_new (line 15) | fn test_writer_new() {
  function test_writer_add_metadata (line 22) | fn test_writer_add_metadata() {
  function test_writer_add_tensor_snapshot (line 41) | fn test_writer_add_tensor_snapshot() {
  function test_writer_to_bytes_empty (line 65) | fn test_writer_to_bytes_empty() {
  function test_writer_to_bytes_with_tensors (line 88) | fn test_writer_to_bytes_with_tensors() {
  function test_writer_all_dtypes (line 153) | fn test_writer_all_dtypes() {
  function test_writer_all_dtypes_round_trip (line 239) | fn test_writer_all_dtypes_round_trip() {
  function test_writer_large_tensor (line 407) | fn test_writer_large_tensor() {
  function test_writer_empty_tensors (line 441) | fn test_writer_empty_tensors() {
  function test_writer_special_characters_in_names (line 466) | fn test_writer_special_characters_in_names() {
  function test_writer_metadata_overwrite (line 516) | fn test_writer_metadata_overwrite() {
  function test_writer_tensor_order_preserved (line 526) | fn test_writer_tensor_order_preserved() {
  function test_writer_lazy_snapshot_evaluation (line 557) | fn test_writer_lazy_snapshot_evaluation() {
  function test_writer_write_to_file (line 602) | fn test_writer_write_to_file() {
  function test_writer_size (line 630) | fn test_writer_size() {
  function test_writer_write_into (line 648) | fn test_writer_write_into() {
  function test_writer_write_into_buffer_too_small (line 671) | fn test_writer_write_into_buffer_too_small() {
  function test_writer_write_into_buffer_larger_than_needed (line 691) | fn test_writer_write_into_buffer_larger_than_needed() {
  function test_writer_write_into_multiple_tensors (line 714) | fn test_writer_write_into_multiple_tensors() {
  function test_writer_write_into_empty (line 740) | fn test_writer_write_into_empty() {

FILE: crates/burn-store/src/burnpack/tests/zero_copy.rs
  type TestBackend (line 10) | type TestBackend = burn_ndarray::NdArray;
  type SimpleModule (line 13) | struct SimpleModule<B: Backend> {
  function new (line 19) | fn new(device: &B::Device) -> Self {
  function new_zeros (line 26) | fn new_zeros(device: &B::Device) -> Self {
  function test_from_static_enables_zero_copy (line 36) | fn test_from_static_enables_zero_copy() {
  function test_zero_copy_builder_method (line 69) | fn test_zero_copy_builder_method() {
  function test_zero_copy_disabled_uses_copy (line 99) | fn test_zero_copy_disabled_uses_copy() {
  function test_from_bytes_uses_copy_by_default (line 129) | fn test_from_bytes_uses_copy_by_default() {
  function test_storage_backend_slice_bytes (line 153) | fn test_storage_backend_slice_bytes() {
  function test_zero_copy_file_based_works (line 185) | fn test_zero_copy_file_based_works() {

FILE: crates/burn-store/src/burnpack/writer.rs
  function align_offset (line 24) | const fn align_offset(offset: u64, alignment: u64) -> u64 {
  type BurnpackWriter (line 29) | pub struct BurnpackWriter {
    method new (line 38) | pub fn new(snapshots: Vec<TensorSnapshot>) -> Self {
    method with_metadata (line 46) | pub fn with_metadata(mut self, key: &str, value: &str) -> Self {
    method build_metadata (line 52) | fn build_metadata(&self) -> Result<(BurnpackMetadata, Vec<u8>), Burnpa...
    method size (line 100) | pub fn size(&self) -> Result<usize, BurnpackError> {
    method write_into (line 131) | pub fn write_into(&self, buffer: &mut [u8]) -> Result<(), BurnpackErro...
    method to_bytes (line 233) | pub fn to_bytes(&self) -> Result<Bytes, BurnpackError> {
    method write_to_file (line 242) | pub fn write_to_file<P: AsRef<Path>>(&self, path: P) -> Result<(), Bur...

FILE: crates/burn-store/src/collector.rs
  type Collector (line 44) | pub struct Collector {
    method new (line 92) | pub fn new(
    method into_tensors (line 108) | pub fn into_tensors(self) -> Vec<TensorSnapshot> {
    method should_collect (line 119) | fn should_collect(&self, path: &[String], container_stack: &[String]) ...
    method enter_module (line 129) | fn enter_module(&mut self, name: &str, container_type: &str) {
    method exit_module (line 140) | fn exit_module(&mut self, _name: &str, container_type: &str) {
    method visit_float (line 149) | fn visit_float<const D: usize>(&mut self, param: &Param<Tensor<B, D>>) {
    method visit_int (line 160) | fn visit_int<const D: usize>(&mut self, param: &Param<Tensor<B, D, Int...
    method visit_bool (line 171) | fn visit_bool<const D: usize>(&mut self, param: &Param<Tensor<B, D, Bo...
    method visit_float_with_path (line 182) | fn visit_float_with_path<const D: usize>(
    method visit_int_with_path (line 199) | fn visit_int_with_path<const D: usize>(
    method visit_bool_with_path (line 215) | fn visit_bool_with_path<const D: usize>(
  method default (line 57) | fn default() -> Self {
  type TestBackend (line 238) | type TestBackend = burn_ndarray::NdArray;
  function tensor_snapshot_collector (line 246) | fn tensor_snapshot_collector() {
  function root_level_parameters (line 266) | fn root_level_parameters() {
  function tensor_snapshot_collector_with_filter (line 313) | fn tensor_snapshot_collector_with_filter() {
  function tensor_snapshot_collector_with_multiple_filters (line 340) | fn tensor_snapshot_collector_with_multiple_filters() {
  function tensor_snapshot_collector_with_predicate (line 376) | fn tensor_snapshot_collector_with_predicate() {
  function tensor_snapshot_collector_predicate_with_complex_logic (line 415) | fn tensor_snapshot_collector_predicate_with_complex_logic() {
  type TensorPathCollector (line 487) | struct TensorPathCollector {
    method new (line 493) | fn new() -> Self {
    method current_path (line 500) | fn current_path(&self) -> String {
    method enter_module (line 506) | fn enter_module(&mut self, name: &str, _container_type: &str) {
    method exit_module (line 510) | fn exit_module(&mut self, _name: &str, _container_type: &str) {
    method visit_float (line 514) | fn visit_float<const D: usize>(&mut self, param: &Param<Tensor<B, D>>) {
    method visit_int (line 524) | fn visit_int<const D: usize>(&mut self, param: &Param<Tensor<B, D, Int...
    method visit_bool (line 534) | fn visit_bool<const D: usize>(&mut self, param: &Param<Tensor<B, D, Bo...
  type InnerModule (line 547) | struct InnerModule<B: Backend> {
  type OuterModule (line 553) | struct OuterModule<B: Backend> {
  function new (line 559) | fn new(device: &B::Device) -> Self {
  function new (line 568) | fn new(device: &B::Device) -> Self {
  function nested_module_path_tracking (line 577) | fn nested_module_path_tracking() {
  function linear_module_paths (line 601) | fn linear_module_paths() {
  type Level4Module (line 622) | struct Level4Module<B: Backend> {
  type Level3Module (line 628) | struct Level3Module<B: Backend> {
  type Level2Module (line 634) | struct Level2Module<B: Backend> {
  type Level1Module (line 640) | struct Level1Module<B: Backend> {
  type DeepModel (line 646) | struct DeepModel<B: Backend> {
  function new (line 652) | fn new(device: &B::Device) -> Self {
  function new (line 661) | fn new(device: &B::Device) -> Self {
  function new (line 670) | fn new(device: &B::Device) -> Self {
  function new (line 679) | fn new(device: &B::Device) -> Self {
  function new (line 688) | fn new(device: &B::Device) -> Self {
  function deep_module_path_tracking (line 697) | fn deep_module_path_tracking() {
  function deep_module_filtered_export (line 745) | fn deep_module_filtered_export() {
  type OptionalFieldModule (line 806) | struct OptionalFieldModule<B: Backend> {
  function new_with_optional (line 812) | fn new_with_optional(device: &B::Device) -> Self {
  function new_without_optional (line 819) | fn new_without_optional(device: &B::Device) -> Self {
  function optional_field_module_with_value (line 828) | fn optional_field_module_with_value() {
  function optional_field_module_without_value (line 844) | fn optional_field_module_without_value() {
  type VecModule (line 861) | struct VecModule<B: Backend> {
  function new (line 866) | fn new(device: &B::Device, num_layers: usize) -> Self {
  type TupleModule (line 877) | struct TupleModule<B: Backend> {
  function new (line 882) | fn new(device: &B::Device) -> Self {
  function vec_module_collect (line 894) | fn vec_module_collect() {
  function tuple_module_collect (line 917) | fn tuple_module_collect() {
  type ArrayModule (line 939) | struct ArrayModule<B: Backend> {
  function new (line 944) | fn new(device: &B::Device) -> Self {
  function array_module_collect (line 956) | fn array_module_collect() {
  type EnumModule (line 978) | enum EnumModule<B: Backend> {
  function enum_module_collect (line 985) | fn enum_module_collect() {
  function linear_container_type (line 1016) | fn linear_container_type() {
  function complex_model_container_types (line 1054) | fn complex_model_container_types() {
  function collect_with_container_filter (line 1098) | fn collect_with_container_filter() {

FILE: crates/burn-store/src/filter.rs
  type PathFilter (line 30) | pub struct PathFilter {
    method new (line 48) | pub fn new() -> Self {
    method all (line 53) | pub fn all() -> Self {
    method none (line 61) | pub fn none() -> Self {
    method with_regex (line 67) | pub fn with_regex<S: AsRef<str>>(mut self, pattern: S) -> Self {
    method with_regexes (line 77) | pub fn with_regexes<I, S>(mut self, patterns: I) -> Self
    method with_full_path (line 91) | pub fn with_full_path<S: Into<String>>(mut self, path: S) -> Self {
    method with_full_paths (line 97) | pub fn with_full_paths<I, S>(mut self, paths: I) -> Self
    method with_predicate (line 107) | pub fn with_predicate(mut self, predicate: fn(&str, &str) -> bool) -> ...
    method with_predicates (line 113) | pub fn with_predicates<I>(mut self, predicates: I) -> Self
    method match_all (line 122) | pub fn match_all(mut self) -> Self {
    method matches (line 128) | pub fn matches(&self, path: &str) -> bool {
    method matches_with_container (line 133) | pub fn matches_with_container(&self, path: &str, container_type: &str)...
    method matches_with_container_path (line 139) | pub fn matches_with_container_path(&self, path: &[String], container_s...
    method matches_with_container_path_str (line 146) | pub fn matches_with_container_path_str(&self, path: &str, container_pa...
    method is_empty (line 185) | pub fn is_empty(&self) -> bool {
    method criteria_count (line 199) | pub fn criteria_count(&self) -> usize {
    method clear_regex (line 217) | pub fn clear_regex(&mut self) -> &mut Self {
    method clear_paths (line 223) | pub fn clear_paths(&mut self) -> &mut Self {
    method clear_predicates (line 229) | pub fn clear_predicates(&mut self) -> &mut Self {
    method clear (line 235) | pub fn clear(&mut self) -> &mut Self {
    method from_regex_patterns (line 246) | pub fn from_regex_patterns<I, S>(patterns: I) -> Self
    method from_paths (line 255) | pub fn from_paths<I, S>(paths: I) -> Self
    method from_predicate (line 264) | pub fn from_predicate(predicate: fn(&str, &str) -> bool) -> Self {
    method or (line 269) | pub fn or(mut self, other: Self) -> Self {
    method fmt (line 287) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function empty_filter (line 322) | fn empty_filter() {
  function match_all (line 330) | fn match_all() {
  function exact_paths (line 339) | fn exact_paths() {
  function regex_patterns (line 352) | fn regex_patterns() {
  function predicates (line 364) | fn predicates() {
  function combined_filters (line 384) | fn combined_filters() {
  function or_combination (line 402) | fn or_combination() {
  function common_patterns (line 415) | fn common_patterns() {
  function criteria_count (line 438) | fn criteria_count() {
  function clear_operations (line 455) | fn clear_operations() {
  function container_predicates (line 466) | fn container_predicates() {
  function container_predicate_with_regex (line 500) | fn container_predicate_with_regex() {
  function container_stack_predicates (line 521) | fn container_stack_predicates() {
  function container_path_dot_notation (line 582) | fn container_path_dot_notation() {

FILE: crates/burn-store/src/keyremapper.rs
  type KeyRemapper (line 27) | pub struct KeyRemapper {
    method new (line 34) | pub fn new() -> Self {
    method add_pattern (line 49) | pub fn add_pattern<S1, S2>(mut self, from: S1, to: S2) -> Result<Self,...
    method from_compiled_patterns (line 60) | pub fn from_compiled_patterns(patterns: Vec<(Regex, String)>) -> Self {
    method from_patterns (line 74) | pub fn from_patterns<S1, S2>(patterns: Vec<(S1, S2)>) -> Result<Self, ...
    method from_pattern_iter (line 99) | pub fn from_pattern_iter<I, S1, S2>(iter: I) -> Result<Self, regex::Er...
    method is_empty (line 115) | pub fn is_empty(&self) -> bool {
    method to_regex_pairs (line 120) | pub fn to_regex_pairs(&self) -> Vec<(Regex, String)> {
    method remap (line 135) | pub fn remap(
  function map_indices_contiguous (line 225) | pub fn map_indices_contiguous(
  function remap_all_indices_with_original_prefix (line 299) | fn remap_all_indices_with_original_prefix(
  function create_test_tensor_snapshot (line 336) | fn create_test_tensor_snapshot(name: &str) -> TensorSnapshot {
  function test_key_remapper_basic (line 347) | fn test_key_remapper_basic() {
  function test_key_remapper_multiple_patterns (line 381) | fn test_key_remapper_multiple_patterns() {
  function test_key_remapper_from_patterns (line 401) | fn test_key_remapper_from_patterns() {
  function test_key_remapper_empty (line 417) | fn test_key_remapper_empty() {
  function test_map_indices_contiguous_basic (line 435) | fn test_map_indices_contiguous_basic() {
  function test_map_indices_contiguous_already_contiguous (line 473) | fn test_map_indices_contiguous_already_contiguous() {
  function test_map_indices_contiguous_multiple_prefixes (line 495) | fn test_map_indices_contiguous_multiple_prefixes() {
  function test_map_indices_contiguous_no_indices (line 532) | fn test_map_indices_contiguous_no_indices() {
  function test_map_indices_contiguous_empty (line 550) | fn test_map_indices_contiguous_empty() {
  function test_map_indices_contiguous_mixed_indexed_and_non_indexed (line 559) | fn test_map_indices_contiguous_mixed_indexed_and_non_indexed() {
  function test_map_indices_contiguous_nested_sequential (line 575) | fn test_map_indices_contiguous_nested_sequential() {
  function test_map_indices_contiguous_deeply_nested (line 642) | fn test_map_indices_contiguous_deeply_nested() {

FILE: crates/burn-store/src/pytorch/lazy_data.rs
  type LazyDataSource (line 17) | pub enum LazyDataSource {
    method from_zip (line 426) | pub fn from_zip(path: impl AsRef<Path>) -> std::io::Result<Self> {
    method from_tar (line 433) | pub fn from_tar(storages_data: &[u8]) -> std::io::Result<Self> {
    method from_legacy_multi_storage (line 440) | pub fn from_legacy_multi_storage(
    method read (line 453) | pub fn read(&self, key: &str) -> std::io::Result<Vec<u8>> {
    method read_range (line 477) | pub fn read_range(&self, key: &str, offset: usize, length: usize) -> s...
    method contains (line 531) | pub fn contains(&self, key: &str) -> bool {
    method keys (line 550) | pub fn keys(&self) -> Vec<String> {
  type ZipSource (line 27) | pub struct ZipSource {
    method new (line 73) | pub fn new(path: PathBuf) -> std::io::Result<Self> {
    method contains (line 96) | pub fn contains(&self, name: &str) -> bool {
    method data_files (line 101) | pub fn data_files(&self) -> Vec<String> {
    method read_file (line 111) | pub fn read_file(&self, name: &str) -> std::io::Result<Vec<u8>> {
    method read_file_range (line 123) | pub fn read_file_range(
  type TarSource (line 41) | pub struct TarSource {
    method new (line 281) | pub fn new(storages_data: Vec<u8>) -> std::io::Result<Self> {
    method read_file (line 373) | pub fn read_file(&self, key: &str) -> std::io::Result<Vec<u8>> {
    method read_file_range (line 390) | pub fn read_file_range(
    method contains (line 413) | pub fn contains(&self, key: &str) -> bool {
    method keys (line 419) | pub fn keys(&self) -> Vec<String> {
  type LegacyMultiStorageSource (line 58) | pub struct LegacyMultiStorageSource {
    method new (line 153) | pub fn new(path: PathBuf, data_offset: u64, data_size: u64) -> Self {
    method set_storage_keys (line 165) | pub fn set_storage_keys(&self, keys: Vec<String>) {
    method track_storage_usage (line 175) | pub fn track_storage_usage(&self, storage_key: &str, offset: usize, si...
    method try_build_storage_map (line 192) | fn try_build_storage_map(&self) {
    method read (line 240) | pub fn read(&self, key: &str) -> std::io::Result<Vec<u8>> {

FILE: crates/burn-store/src/pytorch/pickle_reader.rs
  type PickleError (line 28) | pub enum PickleError {
    method from (line 41) | fn from(e: io::Error) -> Self {
    method fmt (line 47) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Result (line 86) | type Result<T> = std::result::Result<T, PickleError>;
  function storage_type_to_element_size (line 94) | pub fn storage_type_to_element_size(storage_type: &str) -> std::result::...
  type OpCode (line 107) | pub enum OpCode {
    type Error (line 150) | type Error = u8;
    method try_from (line 151) | fn try_from(value: u8) -> std::result::Result<Self, Self::Error> {
  function read_to_newline (line 195) | fn read_to_newline<R: BufRead>(r: &mut R) -> Result<Vec<u8>> {
  function buf_to_str (line 205) | fn buf_to_str(buf: &[u8]) -> Result<String> {
  type Object (line 211) | pub enum Object {
  function rebuild_from_type_v2 (line 237) | fn rebuild_from_type_v2(
  function rebuild_parameter (line 295) | fn rebuild_parameter(
  function parse_storage_arg (line 325) | fn parse_storage_arg(arg: &Object, fn_name: &str) -> Result<(Vec<u8>, Op...
  function parse_shape_arg (line 339) | fn parse_shape_arg(arg: &Object, fn_name: &str) -> Result<Vec<usize>> {
  function rebuild_tensor (line 359) | fn rebuild_tensor(
  function rebuild_tensor_v2 (line 398) | fn rebuild_tensor_v2(
  function storage_type_to_dtype (line 439) | fn storage_type_to_dtype(storage_type: &str) -> Result<DType> {
  function rebuild_tensor_impl (line 460) | fn rebuild_tensor_impl(
  type Stack (line 843) | pub struct Stack {
    method new (line 856) | pub fn new() -> Self {
    method with_data_source (line 865) | pub fn with_data_source(data_source: Arc<LazyDataSource>) -> Self {
    method push (line 873) | fn push(&mut self, o: Object) {
    method pop (line 877) | fn pop(&mut self) -> Result<Object> {
    method top (line 884) | fn top(&self) -> Result<Object> {
    method pop_to_marker (line 891) | fn pop_to_marker(&mut self) -> Result<Vec<Object>> {
    method last_mut (line 906) | fn last_mut(&mut self) -> Result<&mut Object> {
    method push_mark (line 913) | fn push_mark(&mut self) {
    method memo_get (line 920) | fn memo_get(&self, idx: u32) -> Result<Object> {
    method memo_put (line 927) | fn memo_put(&mut self, idx: u32, obj: Object) {
    method memo_len (line 931) | fn memo_len(&self) -> usize {
  method default (line 850) | fn default() -> Self {
  function read_global (line 936) | fn read_global<R: BufRead>(r: &mut R, stack: &mut Stack) -> Result<()> {
  function read_long1 (line 943) | fn read_long1<R: BufRead>(r: &mut R, stack: &mut Stack) -> Result<()> {
  function read_string (line 964) | fn read_string<R: BufRead>(r: &mut R, stack: &mut Stack, len: usize) -> ...
  function read_bin_int (line 972) | fn read_bin_int<R: BufRead>(r: &mut R, stack: &mut Stack) -> Result<()> {
  function read_int (line 978) | fn read_int<R: BufRead>(r: &mut R, stack: &mut Stack) -> Result<()> {
  function read_bin_int1 (line 989) | fn read_bin_int1<R: BufRead>(r: &mut R, stack: &mut Stack) -> Result<()> {
  function read_bin_int2 (line 995) | fn read_bin_int2<R: BufRead>(r: &mut R, stack: &mut Stack) -> Result<()> {
  function read_bin_float (line 1001) | fn read_bin_float<R: BufRead>(r: &mut R, stack: &mut Stack) -> Result<()> {
  function read_pickle (line 1008) | pub fn read_pickle<R: BufRead>(r: &mut R) -> Result<Object> {
  function skip_pickle (line 1016) | pub fn skip_pickle<R: BufRead>(r: &mut R) -> Result<()> {
  function read_pickle_with_data (line 1211) | pub fn read_pickle_with_data<R: BufRead>(
  function get_dict_key (line 1218) | fn get_dict_key(obj: Object) -> Result<String> {
  function read_pickle_with_optional_data (line 1228) | pub fn read_pickle_with_optional_data<R: BufRead>(
  function read_pickle_tensors (line 1498) | pub fn read_pickle_tensors<R: BufRead>(reader: &mut R) -> Result<HashMap...
  function extract_tensors (line 1509) | fn extract_tensors<'a>(

FILE: crates/burn-store/src/pytorch/reader.rs
  type PytorchError (line 53) | pub enum PytorchError {
    method from (line 71) | fn from(e: std::io::Error) -> Self {
    method from (line 77) | fn from(e: PickleError) -> Self {
    method from (line 83) | fn from(e: zip::result::ZipError) -> Self {
    method from (line 89) | fn from(e: burn_core::record::serde::error::Error) -> Self {
    method fmt (line 95) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Result (line 118) | type Result<T> = std::result::Result<T, PytorchError>;
  type PytorchMetadata (line 125) | pub struct PytorchMetadata {
    method is_modern_format (line 144) | pub fn is_modern_format(&self) -> bool {
    method is_legacy_format (line 149) | pub fn is_legacy_format(&self) -> bool {
  type FileFormat (line 156) | pub enum FileFormat {
  type ByteOrder (line 169) | pub enum ByteOrder {
  type PytorchReader (line 201) | pub struct PytorchReader {
    method new (line 214) | pub fn new<P: AsRef<Path>>(path: P) -> Result<Self> {
    method with_top_level_key (line 236) | pub fn with_top_level_key<P: AsRef<Path>>(path: P, key: &str) -> Resul...
    method from_reader (line 249) | pub fn from_reader<R: Read>(reader: R, top_level_key: Option<&str>) ->...
    method keys (line 265) | pub fn keys(&self) -> Vec<String> {
    method get (line 270) | pub fn get(&self, name: &str) -> Option<&TensorSnapshot> {
    method tensors (line 275) | pub fn tensors(&self) -> &HashMap<String, TensorSnapshot> {
    method into_tensors (line 280) | pub fn into_tensors(self) -> HashMap<String, TensorSnapshot> {
    method metadata (line 287) | pub fn metadata(&self) -> &PytorchMetadata {
    method len (line 292) | pub fn len(&self) -> usize {
    method is_empty (line 297) | pub fn is_empty(&self) -> bool {
    method read_pickle_data (line 312) | pub fn read_pickle_data<P: AsRef<Path>>(
    method load_config (line 352) | pub fn load_config<D, P>(path: P, top_level_key: Option<&str>) -> Resu...
  type PickleValue (line 377) | pub enum PickleValue {
  function load_pytorch_file_with_metadata (line 397) | fn load_pytorch_file_with_metadata(
  function load_from_reader (line 629) | fn load_from_reader<R: Read>(
  function extract_tensors_with_data (line 652) | fn extract_tensors_with_data(
  function extract_tensors_recursive (line 688) | fn extract_tensors_recursive<'a>(
  function load_legacy_pytorch_file_with_metadata (line 711) | fn load_legacy_pytorch_file_with_metadata(
  function is_tar_file (line 822) | fn is_tar_file(path: &Path) -> bool {
  function load_tar_pytorch_file_with_metadata (line 835) | fn load_tar_pytorch_file_with_metadata(
  function parse_tar_sys_info (line 930) | fn parse_tar_sys_info(data: &[u8]) -> Result<bool> {
  function read_pickle_as_value (line 944) | fn read_pickle_as_value(path: &Path, top_level_key: Option<&str>) -> Res...
  function convert_object_to_value (line 1030) | fn convert_object_to_value(obj: Object, top_level_key: Option<&str>) -> ...
  function object_to_pickle_value (line 1051) | fn object_to_pickle_value(obj: Object) -> Result<PickleValue> {
  function convert_pickle_to_nested_value (line 1106) | fn convert_pickle_to_nested_value(value: PickleValue) -> Result<NestedVa...

FILE: crates/burn-store/src/pytorch/store.rs
  type PytorchStoreError (line 21) | pub enum PytorchStoreError {
    method fmt (line 39) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 53) | fn from(e: ReaderError) -> Self {
    method from (line 59) | fn from(e: std::io::Error) -> Self {
  type PytorchStore (line 72) | pub struct PytorchStore {
    method from_file (line 98) | pub fn from_file(path: impl Into<PathBuf>) -> Self {
    method with_top_level_key (line 126) | pub fn with_top_level_key(mut self, key: impl Into<String>) -> Self {
    method filter (line 132) | pub fn filter(mut self, filter: PathFilter) -> Self {
    method with_regex (line 148) | pub fn with_regex<S: AsRef<str>>(mut self, pattern: S) -> Self {
    method with_regexes (line 154) | pub fn with_regexes<I, S>(mut self, patterns: I) -> Self
    method with_full_path (line 172) | pub fn with_full_path<S: Into<String>>(mut self, path: S) -> Self {
    method with_full_paths (line 178) | pub fn with_full_paths<I, S>(mut self, paths: I) -> Self
    method with_predicate (line 197) | pub fn with_predicate(mut self, predicate: fn(&str, &str) -> bool) -> ...
    method with_predicates (line 203) | pub fn with_predicates<I>(mut self, predicates: I) -> Self
    method match_all (line 212) | pub fn match_all(mut self) -> Self {
    method remap (line 218) | pub fn remap(mut self, remapper: KeyRemapper) -> Self {
    method with_key_remapping (line 232) | pub fn with_key_remapping(
    method validate (line 245) | pub fn validate(mut self, validate: bool) -> Self {
    method allow_partial (line 251) | pub fn allow_partial(mut self, allow: bool) -> Self {
    method skip_enum_variants (line 272) | pub fn skip_enum_variants(mut self, skip: bool) -> Self {
    method map_indices_contiguous (line 302) | pub fn map_indices_contiguous(mut self, map: bool) -> Self {
    method apply_remapping (line 308) | fn apply_remapping(&self, snapshots: Vec<TensorSnapshot>) -> Vec<Tenso...
    method create_reader (line 318) | fn create_reader(&self) -> Result<PytorchReader, PytorchStoreError> {
    method ensure_snapshots_cache (line 401) | fn ensure_snapshots_cache(&mut self) -> Result<(), PytorchStoreError> {
  type Error (line 329) | type Error = PytorchStoreError;
  method collect_from (line 331) | fn collect_from<B: Backend, M: ModuleSnapshot<B>>(
  method apply_to (line 342) | fn apply_to<B: Backend, M: ModuleSnapshot<B>>(
  method get_snapshot (line 383) | fn get_snapshot(&mut self, name: &str) -> Result<Option<&TensorSnapshot>...
  method get_all_snapshots (line 388) | fn get_all_snapshots(&mut self) -> Result<&BTreeMap<String, TensorSnapsh...
  method keys (line 393) | fn keys(&mut self) -> Result<Vec<String>, Self::Error> {

FILE: crates/burn-store/src/pytorch/tests/reader/create_tar_format.py
  function create_sys_info (line 22) | def create_sys_info():
  function encode_tensor_data (line 36) | def encode_tensor_data(values: list, storage_type: str) -> tuple:
  function write_int (line 54) | def write_int(buffer, value):
  function write_string (line 67) | def write_string(buffer, s):
  function create_storages_blob_manual (line 80) | def create_storages_blob_manual(tensors: list) -> bytes:
  function create_main_pickle_manual (line 130) | def create_main_pickle_manual(tensors_info: list) -> bytes:
  function create_tar_pytorch_file (line 243) | def create_tar_pytorch_file(filename: str, tensors: dict, dtypes: dict):
  function main (line 294) | def main():

FILE: crates/burn-store/src/pytorch/tests/reader/mod.rs
  function test_data_path (line 16) | fn test_data_path(filename: &str) -> PathBuf {
  function test_float32_tensor (line 28) | fn test_float32_tensor() {
  function test_float64_tensor (line 45) | fn test_float64_tensor() {
  function test_int64_tensor (line 61) | fn test_int64_tensor() {
  function test_int32_tensor (line 74) | fn test_int32_tensor() {
  function test_int16_tensor (line 89) | fn test_int16_tensor() {
  function test_int8_tensor (line 103) | fn test_int8_tensor() {
  function test_bool_tensor (line 117) | fn test_bool_tensor() {
  function test_uint8_tensor (line 130) | fn test_uint8_tensor() {
  function test_float16_tensor (line 145) | fn test_float16_tensor() {
  function test_bfloat16_tensor (line 165) | fn test_bfloat16_tensor() {
  function test_2d_tensor (line 185) | fn test_2d_tensor() {
  function test_3d_tensor (line 202) | fn test_3d_tensor() {
  function test_4d_tensor (line 216) | fn test_4d_tensor() {
  function test_state_dict (line 230) | fn test_state_dict() {
  function test_nested_dict (line 267) | fn test_nested_dict() {
  function test_checkpoint (line 296) | fn test_checkpoint() {
  function test_empty_tensor (line 323) | fn test_empty_tensor() {
  function test_scalar_tensor (line 335) | fn test_scalar_tensor() {
  function test_large_shape (line 349) | fn test_large_shape() {
  function test_mixed_types (line 367) | fn test_mixed_types() {
  function test_special_values (line 410) | fn test_special_values() {
  function test_extreme_values (line 430) | fn test_extreme_values() {
  function test_parameter (line 452) | fn test_parameter() {
  function test_buffers (line 469) | fn test_buffers() {
  function test_complex_structure (line 495) | fn test_complex_structure() {
  function test_read_pytorch_tensors_convenience (line 524) | fn test_read_pytorch_tensors_convenience() {
  function test_with_top_level_key (line 542) | fn test_with_top_level_key() {
  function test_legacy_format (line 562) | fn test_legacy_format() {
  function test_legacy_with_offsets (line 606) | fn test_legacy_with_offsets() {
  function test_legacy_shared_storage (line 625) | fn test_legacy_shared_storage() {
  function test_metadata_zip_format (line 658) | fn test_metadata_zip_format() {
  function test_metadata_legacy_format (line 676) | fn test_metadata_legacy_format() {
  function test_legacy_metadata_detailed (line 690) | fn test_legacy_metadata_detailed() {
  function test_small_invalid_file (line 753) | fn test_small_invalid_file() {
  function test_read_pickle_data_basic (line 773) | fn test_read_pickle_data_basic() {
  function test_read_pickle_data_with_key (line 809) | fn test_read_pickle_data_with_key() {
  function test_read_pickle_data_nested_structure (line 836) | fn test_read_pickle_data_nested_structure() {
  function test_read_pickle_data_types (line 866) | fn test_read_pickle_data_types() {
  function test_read_pickle_data_key_not_found (line 892) | fn test_read_pickle_data_key_not_found() {
  function test_read_pickle_data_simple_pickle (line 910) | fn test_read_pickle_data_simple_pickle() {
  function test_load_config_basic (line 937) | fn test_load_config_basic() {
  function test_load_config_with_top_level_key (line 957) | fn test_load_config_with_top_level_key() {
  function test_load_config_complex_types (line 989) | fn test_load_config_complex_types() {
  function test_load_config_key_not_found (line 1013) | fn test_load_config_key_not_found() {
  function test_pickle_value_conversion (line 1031) | fn test_pickle_value_conversion() {
  function test_tar_format_detection (line 1067) | fn test_tar_format_detection() {
  function test_tar_float32_tensor (line 1084) | fn test_tar_float32_tensor() {
  function test_tar_float64_tensor (line 1102) | fn test_tar_float64_tensor() {
  function test_tar_int64_tensor (line 1119) | fn test_tar_int64_tensor() {
  function test_tar_multiple_tensors (line 1133) | fn test_tar_multiple_tensors() {
  function test_tar_multi_dtype (line 1163) | fn test_tar_multi_dtype() {
  function test_tar_2d_tensor_shape (line 1195) | fn test_tar_2d_tensor_shape() {
  function test_tar_metadata (line 1215) | fn test_tar_metadata() {

FILE: crates/burn-store/src/pytorch/tests/reader/test_data.py
  function save_test_file (line 19) | def save_test_file(filename, data, description):

FILE: crates/burn-store/src/pytorch/tests/store/mod.rs
  function pytorch_test_path (line 15) | fn pytorch_test_path(subdir: &str, filename: &str) -> PathBuf {
  function test_data_path (line 24) | fn test_data_path(filename: &str) -> PathBuf {
  function store_test_data_path (line 35) | fn store_test_data_path(filename: &str) -> PathBuf {
  function test_store_creation (line 50) | fn test_store_creation() {
  function test_store_map_indices_contiguous_default (line 60) | fn test_store_map_indices_contiguous_default() {
  function test_store_map_indices_contiguous_disabled (line 70) | fn test_store_map_indices_contiguous_disabled() {
  function test_store_with_top_level_key (line 80) | fn test_store_with_top_level_key() {
  function test_store_configuration (line 86) | fn test_store_configuration() {
  function test_store_with_remapping (line 99) | fn test_store_with_remapping() {
  function test_store_save_not_supported (line 106) | fn test_store_save_not_supported() {
  type TestBackend (line 122) | type TestBackend = burn_ndarray::NdArray;
  type SimpleLinearModel (line 125) | pub struct SimpleLinearModel<B: Backend> {
  function new (line 131) | pub fn new(device: &B::Device) -> Self {
  function forward (line 138) | pub fn forward(&self, x: Tensor<B, 2>) -> Tensor<B, 2> {
  function test_load_linear_model (line 145) | fn test_load_linear_model() {
  function test_load_linear_with_bias (line 174) | fn test_load_linear_with_bias() {
  function test_filter_layers (line 200) | fn test_filter_layers() {
  function test_remap_layer_names (line 221) | fn test_remap_layer_names() {
  type TestBackend (line 256) | type TestBackend = burn_ndarray::NdArray;
  type SimpleConvModel (line 259) | struct SimpleConvModel<B: Backend> {
  function new (line 265) | pub fn new(device: &B::Device) -> Self {
  function test_load_conv2d_model (line 274) | fn test_load_conv2d_model() {
  function test_load_conv1d_model (line 299) | fn test_load_conv1d_model() {
  type TestBackend (line 317) | type TestBackend = burn_ndarray::NdArray;
  function test_load_with_top_level_key (line 320) | fn test_load_with_top_level_key() {
  function test_load_nested_structure (line 332) | fn test_load_nested_structure() {
  function test_legacy_format (line 342) | fn test_legacy_format() {
  function test_key_remap_chained (line 359) | fn test_key_remap_chained() {
  type TestBackend (line 403) | type TestBackend = burn_ndarray::NdArray;
  type SimpleLinearModel (line 406) | pub struct SimpleLinearModel<B: Backend> {
  function new (line 412) | pub fn new(device: &B::Device) -> Self {
  function test_pytorch_adapter_always_applied (line 421) | fn test_pytorch_adapter_always_applied() {
  function test_pytorch_adapter_with_filtering (line 447) | fn test_pytorch_adapter_with_filtering() {
  type SimpleLinearModel (line 483) | pub struct SimpleLinearModel<B: Backend> {
  function new (line 489) | pub fn new(device: &B::Device) -> Self {
  function test_missing_file (line 498) | fn test_missing_file() {
  function test_invalid_top_level_key (line 513) | fn test_invalid_top_level_key() {
  function test_strict_validation (line 535) | fn test_strict_validation() {
  type ConvBlock (line 573) | pub enum ConvBlock<B: Backend> {
  type ModelWithEnum (line 582) | pub struct ModelWithEnum<B: Backend> {
  function new (line 590) | pub fn new(device: &B::Device) -> Self {
  function test_enum_variant_path_mismatch (line 599) | fn test_enum_variant_path_mismatch() {
  function test_enum_variant_detection_in_container_stack (line 674) | fn test_enum_variant_detection_in_container_stack() {
  function test_skip_enum_variants_feature (line 703) | fn test_skip_enum_variants_feature() {
  function test_get_all_snapshots (line 765) | fn test_get_all_snapshots() {
  function test_get_snapshot_existing (line 789) | fn test_get_snapshot_existing() {
  function test_get_snapshot_not_found (line 813) | fn test_get_snapshot_not_found() {
  function test_keys (line 829) | fn test_keys() {
  function test_keys_fast_path (line 852) | fn test_keys_fast_path() {
  function test_caching_behavior (line 877) | fn test_caching_behavior() {
  function test_get_all_snapshots_with_remapping (line 899) | fn test_get_all_snapshots_with_remapping() {
  function test_get_snapshot_with_remapped_name (line 931) | fn test_get_snapshot_with_remapped_name() {
  function test_get_all_snapshots_ignores_filter (line 955) | fn test_get_all_snapshots_ignores_filter() {
  type TestBackend (line 985) | type TestBackend = burn_ndarray::NdArray;
  type SequentialConvModel (line 989) | struct SequentialConvModel<B: Backend> {
  function new (line 994) | pub fn new(device: &B::Device, num_layers: usize) -> Self {
  function test_load_non_contiguous_indexes_with_mapping (line 1008) | fn test_load_non_contiguous_indexes_with_mapping() {
  function test_load_non_contiguous_indexes_without_mapping (line 1086) | fn test_load_non_contiguous_indexes_without_mapping() {
  function test_mapping_applied_to_keys (line 1155) | fn test_mapping_applied_to_keys() {

FILE: crates/burn-store/src/pytorch/tests/store/test_data/generate_enum_test.py
  class SimpleModel (line 19) | class SimpleModel(nn.Module):
    method __init__ (line 32) | def __init__(self):
    method forward (line 43) | def forward(self, x):
  function generate_enum_variant_mismatch_test (line 50) | def generate_enum_variant_mismatch_test():

FILE: crates/burn-store/src/safetensors/store.rs
  type Arc (line 29) | type Arc<T> = Box<T>;
  type SafetensorsStoreError (line 33) | pub enum SafetensorsStoreError {
    method fmt (line 52) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 67) | fn from(e: safetensors::SafeTensorError) -> Self {
    method from (line 74) | fn from(e: std::io::Error) -> Self {
  type SafetensorsStore (line 80) | pub enum SafetensorsStore {
    method default_metadata (line 105) | pub fn default_metadata() -> HashMap<String, String> {
    method from_file (line 115) | pub fn from_file(path: impl Into<std::path::PathBuf>) -> Self {
    method from_bytes (line 135) | pub fn from_bytes(bytes: Option<Vec<u8>>) -> Self {
    method filter (line 155) | pub fn filter(mut self, filter: PathFilter) -> Self {
    method with_regex (line 176) | pub fn with_regex<S: AsRef<str>>(mut self, pattern: S) -> Self {
    method with_regexes (line 187) | pub fn with_regexes<I, S>(mut self, patterns: I) -> Self
    method with_full_path (line 209) | pub fn with_full_path<S: Into<String>>(mut self, path: S) -> Self {
    method with_full_paths (line 219) | pub fn with_full_paths<I, S>(mut self, paths: I) -> Self
    method with_predicate (line 242) | pub fn with_predicate(mut self, predicate: fn(&str, &str) -> bool) -> ...
    method with_predicates (line 252) | pub fn with_predicates<I>(mut self, predicates: I) -> Self
    method match_all (line 265) | pub fn match_all(mut self) -> Self {
    method remap (line 276) | pub fn remap(mut self, remapper: KeyRemapper) -> Self {
    method with_key_remapping (line 294) | pub fn with_key_remapping(
    method metadata (line 319) | pub fn metadata(mut self, key: impl Into<String>, value: impl Into<Str...
    method clear_metadata (line 339) | pub fn clear_metadata(mut self) -> Self {
    method validate (line 353) | pub fn validate(mut self, validate: bool) -> Self {
    method allow_partial (line 363) | pub fn allow_partial(mut self, allow: bool) -> Self {
    method skip_enum_variants (line 392) | pub fn skip_enum_variants(mut self, skip: bool) -> Self {
    method map_indices_contiguous (line 427) | pub fn map_indices_contiguous(mut self, map: bool) -> Self {
    method overwrite (line 450) | pub fn overwrite(mut self, overwrite: bool) -> Self {
    method with_from_adapter (line 461) | pub fn with_from_adapter(mut self, adapter: impl ModuleAdapter + 'stat...
    method with_to_adapter (line 471) | pub fn with_to_adapter(mut self, adapter: impl ModuleAdapter + 'static...
    method get_bytes (line 492) | pub fn get_bytes(&self) -> Result<Vec<u8>, SafetensorsStoreError> {
    method get_filter (line 765) | fn get_filter(&self) -> &PathFilter {
    method get_remapper (line 774) | fn get_remapper(&self) -> &KeyRemapper {
    method get_metadata (line 781) | fn get_metadata(&self) -> &HashMap<String, String> {
    method get_validate (line 789) | fn get_validate(&self) -> bool {
    method get_allow_partial (line 797) | fn get_allow_partial(&self) -> bool {
    method get_skip_enum_variants (line 805) | fn get_skip_enum_variants(&self) -> bool {
    method get_map_indices_contiguous (line 814) | fn get_map_indices_contiguous(&self) -> bool {
    method ensure_snapshots_cache (line 822) | fn ensure_snapshots_cache(&mut self) -> Result<(), SafetensorsStoreErr...
  method default (line 91) | fn default() -> Self {
  type FileStore (line 508) | pub struct FileStore {
  type MemoryStore (line 526) | pub struct MemoryStore {
    method data (line 566) | pub(crate) fn data(&self) -> Option<Arc<Vec<u8>>> {
    method data (line 571) | fn data(&self) -> Option<Arc<Vec<u8>>> {
    method set_data (line 576) | pub(crate) fn set_data(&mut self, data: Vec<u8>) {
  method default (line 545) | fn default() -> Self {
  type TensorSnapshotAdapter (line 583) | struct TensorSnapshotAdapter(TensorSnapshot);
    method dtype (line 586) | fn dtype(&self) -> safetensors::Dtype {
    method shape (line 591) | fn shape(&self) -> &[usize] {
    method data (line 595) | fn data(&self) -> alloc::borrow::Cow<'_, [u8]> {
    method data_len (line 604) | fn data_len(&self) -> usize {
  type Error (line 611) | type Error = SafetensorsStoreError;
  method collect_from (line 613) | fn collect_from<B: Backend, M: ModuleSnapshot<B>>(
  method apply_to (line 686) | fn apply_to<B: Backend, M: ModuleSnapshot<B>>(
  method get_snapshot (line 736) | fn get_snapshot(&mut self, name: &str) -> Result<Option<&TensorSnapshot>...
  method get_all_snapshots (line 747) | fn get_all_snapshots(&mut self) -> Result<&BTreeMap<String, TensorSnapsh...
  method keys (line 758) | fn keys(&mut self) -> Result<Vec<String>, Self::Error> {
  function apply_filter (line 881) | fn apply_filter(mut snapshots: Vec<TensorSnapshot>, filter: &PathFilter)...
  function apply_remapping (line 896) | fn apply_remapping(snapshots: Vec<TensorSnapshot>, remapper: &KeyRemappe...
  function snapshots_to_safetensors (line 906) | fn snapshots_to_safetensors(
  function safetensors_to_snapshots_lazy (line 921) | fn safetensors_to_snapshots_lazy(
  function safetensors_to_snapshots_lazy_file (line 984) | fn safetensors_to_snapshots_lazy_file(
  function safetensor_dtype_to_burn (line 1044) | fn safetensor_dtype_to_burn(dtype: safetensors::Dtype) -> Result<DType, ...
  function dtype_to_safetensors (line 1068) | fn dtype_to_safetensors(dtype: DType) -> Result<safetensors::Dtype, Safe...

FILE: crates/burn-store/src/safetensors/tests/adapter.rs
  type TestBackend (line 11) | type TestBackend = burn_ndarray::NdArray;
  type TestModel (line 14) | struct TestModel<B: Backend> {
  function new (line 21) | fn new(device: &B::Device) -> Self {
  function pytorch_to_burn_adapter_linear_transpose (line 31) | fn pytorch_to_burn_adapter_linear_transpose() {
  function pytorch_to_burn_adapter_norm_rename (line 70) | fn pytorch_to_burn_adapter_norm_rename() {
  function no_adapter_preserves_original (line 123) | fn no_adapter_preserves_original() {
  function adapter_with_pytorch_import (line 158) | fn adapter_with_pytorch_import() {
  function half_precision_adapter_round_trip (line 198) | fn half_precision_adapter_round_trip() {
  function half_precision_adapter_without_module (line 263) | fn half_precision_adapter_without_module() {
  function half_precision_adapter_default_converts_layer_norm (line 312) | fn half_precision_adapter_default_converts_layer_norm() {

FILE: crates/burn-store/src/safetensors/tests/direct_access.rs
  type TestBackend (line 8) | type TestBackend = burn_ndarray::NdArray;
  type DirectAccessTestModule (line 12) | struct DirectAccessTestModule<B: Backend> {
  type DirectAccessNestedModule (line 19) | struct DirectAccessNestedModule<B: Backend> {
  function new (line 25) | fn new(device: &B::Device) -> Self {
  function test_memory_get_all_snapshots (line 38) | fn test_memory_get_all_snapshots() {
  function test_memory_get_snapshot_existing (line 61) | fn test_memory_get_snapshot_existing() {
  function test_memory_get_snapshot_nested (line 85) | fn test_memory_get_snapshot_nested() {
  function test_memory_get_snapshot_not_found (line 106) | fn test_memory_get_snapshot_not_found() {
  function test_memory_keys (line 122) | fn test_memory_keys() {
  function test_memory_caching_behavior (line 141) | fn test_memory_caching_behavior() {
  function test_file_get_all_snapshots (line 169) | fn test_file_get_all_snapshots() {
  function test_file_get_snapshot_existing (line 193) | fn test_file_get_snapshot_existing() {
  function test_file_get_snapshot_not_found (line 220) | fn test_file_get_snapshot_not_found() {
  function test_file_keys (line 240) | fn test_file_keys() {
  function test_file_keys_fast_path (line 264) | fn test_file_keys_fast_path() {
  function test_file_caching_behavior (line 294) | fn test_file_caching_behavior() {
  function test_file_cache_invalidation_on_save (line 319) | fn test_file_cache_invalidation_on_save() {

FILE: crates/burn-store/src/safetensors/tests/error_handling.rs
  type TestBackend (line 4) | type TestBackend = burn_ndarray::NdArray;
  function shape_mismatch_errors (line 7) | fn shape_mismatch_errors() {

FILE: crates/burn-store/src/safetensors/tests/file_io.rs
  type TestBackend (line 11) | type TestBackend = burn_ndarray::NdArray;
  type ForwardTestModel (line 15) | struct ForwardTestModel<B: burn_tensor::backend::Backend> {
  function forward (line 21) | fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2> {
  type ForwardTestModelConfig (line 30) | struct ForwardTestModelConfig {
    method init (line 37) | fn init<B: burn_tensor::backend::Backend>(&self, device: &B::Device) -...
  type ModuleBasic (line 50) | pub struct ModuleBasic<B: Backend> {
  function new (line 55) | fn new(device: &B::Device) -> Self {
  type ModuleComposed (line 67) | pub struct ModuleComposed<B: Backend> {
  function new (line 74) | fn new(device: &B::Device) -> Self {
  function file_based_loading (line 90) | fn file_based_loading() {
  function test_store_overwrite_protection (line 127) | fn test_store_overwrite_protection() {
  function test_store_overwrite_with_metadata (line 169) | fn test_store_overwrite_with_metadata() {
  function test_forward_pass_preservation_after_save_load (line 204) | fn test_forward_pass_preservation_after_save_load() {
  function should_save_load_compose (line 264) | fn should_save_load_compose() {

FILE: crates/burn-store/src/safetensors/tests/filtering.rs
  type TestBackend (line 5) | type TestBackend = burn_ndarray::NdArray;
  function filtered_export_import (line 9) | fn filtered_export_import() {
  function builder_pattern_filtering (line 36) | fn builder_pattern_filtering() {
  function builder_pattern_exact_paths (line 65) | fn builder_pattern_exact_paths() {
  function builder_pattern_with_predicate (line 90) | fn builder_pattern_with_predicate() {
  function builder_pattern_combined (line 115) | fn builder_pattern_combined() {
  function builder_pattern_match_all (line 152) | fn builder_pattern_match_all() {

FILE: crates/burn-store/src/safetensors/tests/integration.rs
  type TestBackend (line 8) | type TestBackend = burn_ndarray::NdArray;
  type IntegrationTestModel (line 12) | struct IntegrationTestModel<B: Backend> {
  type IntegrationEncoderModule (line 19) | struct IntegrationEncoderModule<B: Backend> {
  type IntegrationDecoderModule (line 26) | struct IntegrationDecoderModule<B: Backend> {
  type IntegrationHeadModule (line 33) | struct IntegrationHeadModule<B: Backend> {
  type IntegrationLinearLayer (line 39) | struct IntegrationLinearLayer<B: Backend> {
  type IntegrationNormLayer (line 45) | struct IntegrationNormLayer<B: Backend> {
  function new (line 51) | fn new(device: &B::Device) -> Self {
  function new (line 61) | fn new(device: &B::Device) -> Self {
  function new (line 71) | fn new(device: &B::Device) -> Self {
  function new (line 81) | fn new(device: &B::Device) -> Self {
  function new (line 90) | fn new(device: &B::Device, seed: i32) -> Self {
  function new (line 105) | fn new(device: &B::Device) -> Self {
  function basic_usage (line 114) | fn basic_usage() {
  function with_filtering (line 143) | fn with_filtering() {

FILE: crates/burn-store/src/safetensors/tests/metadata.rs
  type TestBackend (line 4) | type TestBackend = burn_ndarray::NdArray;
  function default_metadata_included (line 7) | fn default_metadata_included() {
  function metadata_preservation (line 22) | fn metadata_preservation() {
  function clear_metadata_removes_all (line 55) | fn clear_metadata_removes_all() {
  function clear_then_add_custom_metadata (line 87) | fn clear_then_add_custom_metadata() {

FILE: crates/burn-store/src/safetensors/tests/mixed_datatypes.rs
  type MixedDtypeModel (line 11) | pub struct MixedDtypeModel<B: Backend> {
  function new (line 24) | pub fn new(device: &B::Device) -> Self {
  function test_mixed_dtypes_round_trip (line 63) | fn test_mixed_dtypes_round_trip() {
  function test_dtype_detection (line 99) | fn test_dtype_detection() {
  function test_extreme_values (line 142) | fn test_extreme_values() {
  function test_mixed_precision_floats (line 204) | fn test_mixed_precision_floats() {
  function test_mixed_precision_integers (line 284) | fn test_mixed_precision_integers() {
  function test_comprehensive_mixed_types (line 347) | fn test_comprehensive_mixed_types() {

FILE: crates/burn-store/src/safetensors/tests/multi_layer_verify.rs
  type Net (line 14) | pub struct Net<B: Backend> {
  function new (line 23) | pub fn new(device: &B::Device) -> Self {
  function forward (line 35) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 2> {
  type TestBackend (line 48) | type TestBackend = burn_ndarray::NdArray;
  function get_safetensors_path (line 51) | fn get_safetensors_path() -> &'static str {
  function multi_layer_model (line 59) | fn multi_layer_model() {

FILE: crates/burn-store/src/safetensors/tests/pytorch_import.rs
  type TestBackend (line 12) | type TestBackend = burn_ndarray::NdArray;
  type Net (line 15) | pub struct Net<B: Backend> {
  function new (line 23) | pub fn new(device: &B::Device) -> Self {
  function forward (line 35) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 2> {
  function multi_layer_model_import (line 47) | fn multi_layer_model_import() {
  function safetensors_round_trip_with_pytorch_model (line 90) | fn safetensors_round_trip_with_pytorch_model() {
  function partial_load_from_pytorch_model (line 146) | fn partial_load_from_pytorch_model() {
  function verify_tensor_names_from_pytorch (line 177) | fn verify_tensor_names_from_pytorch() {

FILE: crates/burn-store/src/safetensors/tests/round_trip.rs
  type TestBackend (line 9) | type TestBackend = burn_ndarray::NdArray;
  type ComplexModule (line 12) | pub(super) struct ComplexModule<B: Backend> {
  type EncoderModule (line 19) | pub(super) struct EncoderModule<B: Backend> {
  type DecoderModule (line 26) | pub(super) struct DecoderModule<B: Backend> {
  function new (line 32) | pub fn new(device: &B::Device) -> Self {
  function new_zeros (line 53) | pub fn new_zeros(device: &B::Device) -> Self {
  function complex_module_round_trip (line 73) | fn complex_module_round_trip() {

FILE: crates/burn-store/src/tensor_snapshot.rs
  function quant_param_size (line 12) | const fn quant_param_size(param: QuantParam) -> usize {
  type TensorSnapshotError (line 22) | pub enum TensorSnapshotError {
    method fmt (line 32) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type TensorSnapshot (line 51) | pub struct TensorSnapshot {
    method from_float (line 68) | pub fn from_float<B: Backend, const D: usize>(
    method from_int (line 88) | pub fn from_int<B: Backend, const D: usize>(
    method from_bool (line 108) | pub fn from_bool<B: Backend, const D: usize>(
    method to_data (line 129) | pub fn to_data(&self) -> Result<TensorData, TensorSnapshotError> {
    method to_data (line 142) | pub fn to_data(&self) -> Result<TensorData, TensorSnapshotError> {
    method full_path (line 147) | pub fn full_path(&self) -> String {
    method container_path (line 155) | pub fn container_path(&self) -> String {
    method module_type (line 173) | pub fn module_type(&self) -> Option<String> {
    method container_type (line 194) | pub fn container_type(&self) -> String {
    method from_closure (line 204) | pub fn from_closure(
    method from_data (line 223) | pub fn from_data(
    method data_len (line 249) | pub fn data_len(&self) -> usize {
    method clone_data_fn (line 274) | pub fn clone_data_fn(&self) -> Rc<dyn Fn() -> Result<TensorData, Tenso...
    method fmt (line 294) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  method clone (line 280) | fn clone(&self) -> Self {
  type TestBackend (line 308) | type TestBackend = burn_ndarray::NdArray;
  function tensor_view_float (line 313) | fn tensor_view_float() {
  function tensor_view_int (line 337) | fn tensor_view_int() {
  function tensor_view_bool (line 359) | fn tensor_view_bool() {
  function data_len (line 381) | fn data_len() {
  function from_closure (line 418) | fn from_closure() {
  function from_data (line 444) | fn from_data() {
  function panic_catching_in_to_data (line 470) | fn panic_catching_in_to_data() {
  function error_propagation_in_closure (line 496) | fn error_propagation_in_closure() {
  function container_type_extraction (line 521) | fn container_type_extraction() {
  function container_type_vs_module_type (line 550) | fn container_type_vs_module_type() {

FILE: crates/burn-store/src/traits.rs
  type ModuleSnapshot (line 18) | pub trait ModuleSnapshot<B: Backend>: Module<B> {
    method collect (line 34) | fn collect(
    method apply (line 86) | fn apply(
    method save_into (line 123) | fn save_into<P>(&self, store: &mut P) -> Result<(), P::Error>
    method load_from (line 138) | fn load_from<P>(&mut self, store: &mut P) -> Result<ApplyResult, P::Er...
  type ModuleStore (line 151) | pub trait ModuleStore {
    method collect_from (line 174) | fn collect_from<B: Backend, M: ModuleSnapshot<B>>(
    method apply_to (line 198) | fn apply_to<B: Backend, M: ModuleSnapshot<B>>(
    method get_snapshot (line 234) | fn get_snapshot(&mut self, name: &str) -> Result<Option<&TensorSnapsho...
    method get_all_snapshots (line 262) | fn get_all_snapshots(&mut self) -> Result<&BTreeMap<String, TensorSnap...
    method keys (line 284) | fn keys(&mut self) -> Result<Vec<String>, Self::Error>;

FILE: crates/burn-tch/build.rs
  constant PYTHON_PRINT_PYTORCH_DETAILS (line 12) | const PYTHON_PRINT_PYTORCH_DETAILS: &str = r"
  type Os (line 24) | enum Os {
  type SystemInfo (line 32) | struct SystemInfo {
    method new (line 45) | fn new() -> Option<Self> {
    method check_system_location (line 120) | fn check_system_location(os: Os) -> Option<PathBuf> {
    method prepare_libtorch_dir (line 129) | fn prepare_libtorch_dir(os: Os) -> Option<PathBuf> {
    method make (line 141) | fn make(&self, use_cuda: bool, use_hip: bool) {
    method make_cpu (line 175) | fn make_cpu() {
  function env_var_rerun (line 39) | fn env_var_rerun(name: &str) -> Result<String, env::VarError> {
  function check_out_dir (line 204) | fn check_out_dir() -> Option<PathBuf> {
  function main (line 210) | fn main() {

FILE: crates/burn-tch/src/backend.rs
  type LibTorchDevice (line 27) | pub enum LibTorchDevice {
    method from (line 62) | fn from(device: tch::Device) -> Self {
    method from_id (line 73) | fn from_id(device_id: DeviceId) -> Self {
    method to_id (line 83) | fn to_id(&self) -> DeviceId {
    method device_count (line 92) | fn device_count(_type_id: u16) -> usize {
  function from (line 48) | fn from(device: LibTorchDevice) -> Self {
  type LibTorch (line 110) | pub struct LibTorch<E = f32> {
  type Device (line 115) | type Device = LibTorchDevice;
  type FloatTensorPrimitive (line 117) | type FloatTensorPrimitive = TchTensor;
  type FloatElem (line 118) | type FloatElem = E;
  type IntTensorPrimitive (line 120) | type IntTensorPrimitive = TchTensor;
  type IntElem (line 121) | type IntElem = i64;
  type BoolTensorPrimitive (line 122) | type BoolTensorPrimitive = TchTensor;
  type BoolElem (line 123) | type BoolElem = bool;
  type QuantizedTensorPrimitive (line 125) | type QuantizedTensorPrimitive = TchTensor;
  method seed (line 127) | fn seed(_device: &Self::Device, seed: u64) {
  method ad_enabled (line 131) | fn ad_enabled(_device: &Self::Device) -> bool {
  method name (line 135) | fn name(device: &Self::Device) -> String {
  method sync (line 145) | fn sync(device: &Self::Device) -> Result<(), ExecutionError> {
  method dtype_usage (line 165) | fn dtype_usage(

FILE: crates/burn-tch/src/bin/cpu.rs
  function main (line 4) | fn main() {

FILE: crates/burn-tch/src/bin/cuda.rs
  function main (line 4) | fn main() {

FILE: crates/burn-tch/src/bin/mps.rs
  function main (line 4) | fn main() {

FILE: crates/burn-tch/src/cuda_hack/dummy_cuda_dependency.cpp
  type cublasContext (line 10) | struct cublasContext
  type at (line 12) | namespace at {
    type cuda (line 13) | namespace cuda {
  function dummy_cuda_dependency (line 19) | void dummy_cuda_dependency() {

FILE: crates/burn-tch/src/cuda_hack/fake_cuda_dependency.cpp
  function dummy_cuda_dependency (line 5) | void dummy_cuda_dependency() {}

FILE: crates/burn-tch/src/element.rs
  type TchElement (line 5) | pub trait TchElement: Element + tch::kind::Element {
    method kind (line 7) | fn kind() -> tch::Kind {
    method kind (line 16) | fn kind() -> tch::Kind {
  function test_elem_kinds (line 40) | fn test_elem_kinds() {

FILE: crates/burn-tch/src/ops/activation.rs
  function relu (line 5) | fn relu(tensor: TchTensor) -> TchTensor {
  function gelu (line 9) | fn gelu(tensor: TchTensor) -> TchTensor {
  function gelu_backward (line 16) | fn gelu_backward(tensor: TchTensor, grad: TchTensor) -> TchTensor {
  function sigmoid (line 23) | fn sigmoid(tensor: TchTensor) -> TchTensor {
  function log_sigmoid (line 27) | fn log_sigmoid(tensor: TchTensor) -> TchTensor {

FILE: crates/burn-tch/src/ops/base.rs
  type TchOps (line 6) | pub struct TchOps {
    method to_device (line 11) | pub fn to_device(tensor: TchTensor, device: &LibTorchDevice) -> TchTen...
    method reshape (line 23) | pub fn reshape(tensor: TchTensor, shape: Shape) -> TchTensor {
    method repeat_dim (line 29) | pub fn repeat_dim(tensor: TchTensor, dim: usize, times: usize) -> TchT...
    method slice_with_steps (line 36) | pub fn slice_with_steps(tensor: TchTensor, slices: &[burn_backend::Sli...
    method slice_assign (line 77) | pub fn slice_assign(
    method generate_slice_indices (line 125) | fn generate_slice_indices(slice: &burn_backend::Slice, dim_size: usize...
    method slice_assign_with_advanced_indexing (line 151) | fn slice_assign_with_advanced_indexing(
    method gather (line 214) | pub fn gather(dim: usize, tensor: TchTensor, indices: TchTensor) -> Tc...
    method scatter (line 221) | pub fn scatter(
    method index_select_dim (line 235) | pub fn index_select_dim(tensor: TchTensor, dim: usize, indices: TchTen...
    method select_assign (line 242) | pub fn select_assign(
    method cat (line 254) | pub fn cat(tensors: Vec<TchTensor>, dim: usize) -> TchTensor {
    method equal (line 264) | pub fn equal(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method equal_elem (line 274) | pub fn equal_elem<S: Into<tch::Scalar> + Clone>(lhs: TchTensor, rhs: S...
    method greater (line 281) | pub fn greater(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method greater_elem (line 291) | pub fn greater_elem<S: Into<tch::Scalar> + Clone>(lhs: TchTensor, rhs:...
    method greater_equal (line 298) | pub fn greater_equal(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method greater_equal_elem (line 308) | pub fn greater_equal_elem<S: Into<Scalar> + Clone>(lhs: TchTensor, rhs...
    method lower (line 319) | pub fn lower(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method lower_elem (line 329) | pub fn lower_elem<S: Into<Scalar> + Clone>(lhs: TchTensor, rhs: S) -> ...
    method lower_equal (line 336) | pub fn lower_equal(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method lower_equal_elem (line 346) | pub fn lower_equal_elem<S: Into<Scalar> + Clone>(lhs: TchTensor, rhs: ...
    method add (line 357) | pub fn add(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method sub (line 367) | pub fn sub(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method mul (line 377) | pub fn mul(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method div (line 387) | pub fn div(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method remainder (line 397) | pub fn remainder(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method mean (line 407) | pub fn mean(tensor: TchTensor) -> TchTensor {
    method mean_dim (line 413) | pub fn mean_dim(tensor: TchTensor, dim: usize) -> TchTensor {
    method sum (line 422) | pub fn sum(tensor: TchTensor) -> TchTensor {
    method sum_dim (line 428) | pub fn sum_dim(tensor: TchTensor, dim: usize) -> TchTensor {
    method prod (line 439) | pub fn prod(tensor: TchTensor) -> TchTensor {
    method prod_dim (line 445) | pub fn prod_dim(tensor: TchTensor, dim: usize) -> TchTensor {
    method cumsum (line 454) | pub fn cumsum(tensor: TchTensor, dim: usize) -> TchTensor {
    method cumprod (line 461) | pub fn cumprod(tensor: TchTensor, dim: usize) -> TchTensor {
    method cummin (line 468) | pub fn cummin(tensor: TchTensor, dim: usize) -> TchTensor {
    method cummax (line 473) | pub fn cummax(tensor: TchTensor, dim: usize) -> TchTensor {
    method argmax (line 479) | pub fn argmax(tensor: TchTensor, dim: usize) -> TchTensor {
    method argmin (line 486) | pub fn argmin(tensor: TchTensor, dim: usize) -> TchTensor {
    method max_dim (line 493) | pub fn max_dim(tensor: TchTensor, dim: usize) -> TchTensor {
    method max_dim_with_indices (line 500) | pub fn max_dim_with_indices(tensor: TchTensor, dim: usize) -> (TchTens...
    method min_dim (line 510) | pub fn min_dim(tensor: TchTensor, dim: usize) -> TchTensor {
    method min_dim_with_indices (line 517) | pub fn min_dim_with_indices(tensor: TchTensor, dim: usize) -> (TchTens...
    method clamp_min (line 527) | pub fn clamp_min<S: Into<tch::Scalar> + Clone + Copy>(tensor: TchTenso...
    method clamp_max (line 534) | pub fn clamp_max<S: Into<tch::Scalar> + Clone + Copy>(tensor: TchTenso...
    method clamp (line 541) | pub fn clamp<S: Into<tch::Scalar> + Clone + Copy>(
    method swap_dims (line 552) | pub fn swap_dims(tensor: TchTensor, dim1: usize, dim2: usize) -> TchTe...
    method permute (line 557) | pub fn permute(tensor: TchTensor, axes: &[usize]) -> TchTensor {
    method flip (line 564) | pub fn flip(tensor: TchTensor, axes: &[usize]) -> TchTensor {
    method powf (line 570) | pub fn powf(tensor: TchTensor, exponent: TchTensor) -> TchTensor {
    method sign (line 580) | pub fn sign(tensor: TchTensor) -> TchTensor {
    method expand (line 584) | pub fn expand(tensor: TchTensor, shape: Shape) -> TchTensor {
    method unfold (line 590) | pub fn unfold(tensor: TchTensor, dim: usize, size: usize, step: usize)...
    method sort (line 597) | pub fn sort(tensor: TchTensor, dim: usize, descending: bool) -> TchTen...
    method sort_with_indices (line 601) | pub fn sort_with_indices(
    method argsort (line 610) | pub fn argsort(tensor: TchTensor, dim: usize, descending: bool) -> Tch...
    method bitwise_and (line 614) | pub fn bitwise_and(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method bitwise_and_scalar (line 624) | pub fn bitwise_and_scalar<S: Into<Scalar> + Clone>(tensor: TchTensor, ...
    method bitwise_or (line 631) | pub fn bitwise_or(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method bitwise_or_scalar (line 641) | pub fn bitwise_or_scalar<S: Into<Scalar> + Clone>(tensor: TchTensor, s...
    method bitwise_xor (line 648) | pub fn bitwise_xor(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method bitwise_xor_scalar (line 658) | pub fn bitwise_xor_scalar<S: Into<Scalar> + Clone>(tensor: TchTensor, ...
    method bitwise_not (line 665) | pub fn bitwise_not(tensor: TchTensor) -> TchTensor {
    method bitwise_left_shift (line 672) | pub fn bitwise_left_shift(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method bitwise_left_shift_scalar (line 682) | pub fn bitwise_left_shift_scalar<S: Into<Scalar> + Clone>(
    method bitwise_right_shift (line 700) | pub fn bitwise_right_shift(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
    method bitwise_right_shift_scalar (line 710) | pub fn bitwise_right_shift_scalar<S: Into<Scalar> + Clone>(
    method atan2 (line 728) | pub fn atan2(lhs: TchTensor, rhs: TchTensor) -> TchTensor {

FILE: crates/burn-tch/src/ops/bool_tensor.rs
  function bool_from_data (line 11) | fn bool_from_data(data: TensorData, device: &LibTorchDevice) -> TchTensor {
  function bool_repeat_dim (line 20) | fn bool_repeat_dim(tensor: TchTensor, dim: usize, times: usize) -> TchTe...
  function bool_into_data (line 24) | async fn bool_into_data(tensor: TchTensor) -> Result<TensorData, Executi...
  function bool_to_device (line 31) | fn bool_to_device(tensor: TchTensor, device: &LibTorchDevice) -> TchTens...
  function bool_reshape (line 35) | fn bool_reshape(tensor: TchTensor, shape: Shape) -> TchTensor {
  function bool_device (line 39) | fn bool_device(tensor: &TchTensor) -> LibTorchDevice {
  function bool_empty (line 43) | fn bool_empty(shape: Shape, device: &LibTorchDevice) -> TchTensor {
  function bool_zeros (line 52) | fn bool_zeros(shape: Shape, device: &LibTorchDevice) -> TchTensor {
  function bool_ones (line 61) | fn bool_ones(shape: Shape, device: &LibTorchDevice) -> TchTensor {
  function bool_slice (line 70) | fn bool_slice(tensor: TchTensor, slices: &[burn_backend::Slice]) -> TchT...
  function bool_slice_assign (line 74) | fn bool_slice_assign(
  function bool_cat (line 82) | fn bool_cat(tensors: Vec<TchTensor>, dim: usize) -> TchTensor {
  function bool_equal (line 86) | fn bool_equal(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function bool_not (line 90) | fn bool_not(tensor: TchTensor) -> TchTensor {
  function bool_and (line 97) | fn bool_and(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function bool_or (line 107) | fn bool_or(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function bool_into_int (line 117) | fn bool_into_int(tensor: TchTensor) -> TchTensor {
  function bool_into_float (line 122) | fn bool_into_float(tensor: TchTensor) -> TchTensor {
  function bool_swap_dims (line 127) | fn bool_swap_dims(tensor: TchTensor, dim1: usize, dim2: usize) -> TchTen...
  function bool_permute (line 131) | fn bool_permute(tensor: TchTensor, axes: &[usize]) -> TchTensor {
  function bool_flip (line 135) | fn bool_flip(tensor: TchTensor, axes: &[usize]) -> TchTensor {
  function bool_argwhere (line 139) | async fn bool_argwhere(tensor: TchTensor) -> TchTensor {
  function bool_select (line 143) | fn bool_select(tensor: TchTensor, dim: usize, indices: TchTensor) -> Tch...
  function bool_select_or (line 147) | fn bool_select_or(
  function bool_expand (line 156) | fn bool_expand(tensor: TchTensor, shape: Shape) -> TchTensor {
  function bool_unfold (line 160) | fn bool_unfold(
  function bool_mask_where (line 169) | fn bool_mask_where(
  function bool_mask_fill (line 183) | fn bool_mask_fill(
  function bool_gather (line 202) | fn bool_gather(
  function bool_scatter_or (line 210) | fn bool_scatter_or(
  function bool_equal_elem (line 219) | fn bool_equal_elem(lhs: BoolTensor<Self>, rhs: Scalar) -> BoolTensor<Sel...

FILE: crates/burn-tch/src/ops/int_tensor.rs
  function int_from_data (line 14) | fn int_from_data(data: TensorData, device: &LibTorchDevice) -> TchTensor {
  function int_repeat_dim (line 21) | fn int_repeat_dim(tensor: TchTensor, dim: usize, times: usize) -> TchTen...
  function int_into_data (line 25) | async fn int_into_data(tensor: TchTensor) -> Result<TensorData, Executio...
  function int_to_device (line 32) | fn int_to_device(tensor: TchTensor, device: &LibTorchDevice) -> TchTensor {
  function int_reshape (line 36) | fn int_reshape(tensor: TchTensor, shape: Shape) -> TchTensor {
  function int_device (line 40) | fn int_device(tensor: &TchTensor) -> LibTorchDevice {
  function int_empty (line 44) | fn int_empty(shape: Shape, device: &LibTorchDevice, dtype: IntDType) -> ...
  function int_slice (line 53) | fn int_slice(tensor: TchTensor, slices: &[burn_backend::Slice]) -> TchTe...
  function int_slice_assign (line 57) | fn int_slice_assign(
  function int_cat (line 65) | fn int_cat(tensors: Vec<TchTensor>, dim: usize) -> TchTensor {
  function int_matmul (line 69) | fn int_matmul(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  function int_equal (line 76) | fn int_equal(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function int_equal_elem (line 80) | fn int_equal_elem(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function int_greater (line 84) | fn int_greater(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function int_greater_elem (line 88) | fn int_greater_elem(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function int_greater_equal (line 92) | fn int_greater_equal(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function int_greater_equal_elem (line 96) | fn int_greater_equal_elem(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function int_lower (line 100) | fn int_lower(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function int_lower_elem (line 104) | fn int_lower_elem(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function int_lower_equal (line 108) | fn int_lower_equal(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function int_lower_equal_elem (line 112) | fn int_lower_equal_elem(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function int_add (line 116) | fn int_add(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function int_add_scalar (line 120) | fn int_add_scalar(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function int_sub (line 127) | fn int_sub(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function int_sub_scalar (line 131) | fn int_sub_scalar(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function int_mul (line 138) | fn int_mul(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function int_mul_scalar (line 142) | fn int_mul_scalar(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function int_div (line 149) | fn int_div(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function int_div_scalar (line 163) | fn int_div_scalar(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function int_remainder (line 178) | fn int_remainder(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function int_remainder_scalar (line 192) | fn int_remainder_scalar(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function int_zeros (line 199) | fn int_zeros(shape: Shape, device: &LibTorchDevice, dtype: IntDType) -> ...
  function int_ones (line 206) | fn int_ones(shape: Shape, device: &LibTorchDevice, dtype: IntDType) -> T...
  function int_full (line 213) | fn int_full(
  function int_sum (line 229) | fn int_sum(tensor: TchTensor) -> TchTensor {
  function int_sum_dim (line 233) | fn int_sum_dim(tensor: TchTensor, dim: usize) -> TchTensor {
  function int_prod (line 237) | fn int_prod(tensor: TchTensor) -> TchTensor {
  function int_prod_dim (line 241) | fn int_prod_dim(tensor: TchTensor, dim: usize) -> TchTensor {
  function int_mean (line 245) | fn int_mean(tensor: TchTensor) -> TchTensor {
  function int_mean_dim (line 254) | fn int_mean_dim(tensor: TchTensor, dim: usize) -> TchTensor {
  function int_cumsum (line 264) | fn int_cumsum(tensor: TchTensor, dim: usize) -> TchTensor {
  function int_cumprod (line 268) | fn int_cumprod(tensor: TchTensor, dim: usize) -> TchTensor {
  function int_cummin (line 272) | fn int_cummin(tensor: TchTensor, dim: usize) -> TchTensor {
  function int_cummax (line 276) | fn int_cummax(tensor: TchTensor, dim: usize) -> TchTensor {
  function int_gather (line 280) | fn int_gather(dim: usize, tensor: TchTensor, indices: TchTensor) -> TchT...
  function int_scatter_add (line 284) | fn int_scatter_add(
  function int_select (line 293) | fn int_select(tensor: TchTensor, dim: usize, indices: TchTensor) -> TchT...
  function int_select_add (line 297) | fn int_select_add(
  function int_mask_where (line 306) | fn int_mask_where(tensor: TchTensor, mask: TchTensor, source: TchTensor)...
  function int_mask_fill (line 316) | fn int_mask_fill(tensor: TchTensor, mask: TchTensor, value: Scalar) -> T...
  function int_argmax (line 324) | fn int_argmax(tensor: TchTensor, dim: usize) -> TchTensor {
  function int_argmin (line 328) | fn int_argmin(tensor: TchTensor, dim: usize) -> TchTensor {
  function int_max_dim (line 332) | fn int_max_dim(tensor: TchTensor, dim: usize) -> TchTensor {
  function int_max_dim_with_indices (line 336) | fn int_max_dim_with_indices(tensor: TchTensor, dim: usize) -> (TchTensor...
  function int_min_dim (line 340) | fn int_min_dim(tensor: TchTensor, dim: usize) -> TchTensor {
  function int_min_dim_with_indices (line 344) | fn int_min_dim_with_indices(tensor: TchTensor, dim: usize) -> (TchTensor...
  function int_clamp_min (line 348) | fn int_clamp_min(tensor: TchTensor, min: Scalar) -> TchTensor {
  function int_clamp_max (line 352) | fn int_clamp_max(tensor: TchTensor, max: Scalar) -> TchTensor {
  function int_clamp (line 356) | fn int_clamp(tensor: TchTensor, min: Scalar, max: Scalar) -> TchTensor {
  function int_abs (line 360) | fn int_abs(tensor: TchTensor) -> TchTensor {
  function int_into_float (line 364) | fn int_into_float(tensor: TchTensor) -> TchTensor {
  function int_swap_dims (line 369) | fn int_swap_dims(tensor: IntTensor<Self>, dim1: usize, dim2: usize) -> I...
  function int_random (line 373) | fn int_random(shape: Shape, distribution: Distribution, device: &LibTorc...
  function int_arange (line 400) | fn int_arange(range: Range<i64>, device: &LibTorchDevice) -> TchTensor {
  function int_permute (line 411) | fn int_permute(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Sel...
  function int_flip (line 415) | fn int_flip(tensor: IntTensor<Self>, axes: &[usize]) -> IntTensor<Self> {
  function int_sign (line 419) | fn int_sign(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function int_expand (line 423) | fn int_expand(tensor: IntTensor<Self>, shape: Shape) -> IntTensor<Self> {
  function int_sort (line 427) | fn int_sort(tensor: IntTensor<Self>, dim: usize, descending: bool) -> In...
  function int_argsort (line 431) | fn int_argsort(tensor: IntTensor<Self>, dim: usize, descending: bool) ->...
  function bitwise_and (line 435) | fn bitwise_and(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  function bitwise_or (line 439) | fn bitwise_or(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<S...
  function bitwise_xor (line 443) | fn bitwise_xor(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> IntTensor<...
  function bitwise_not (line 447) | fn bitwise_not(tensor: IntTensor<Self>) -> IntTensor<Self> {
  function bitwise_and_scalar (line 451) | fn bitwise_and_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  function bitwise_or_scalar (line 455) | fn bitwise_or_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Sel...
  function bitwise_xor_scalar (line 459) | fn bitwise_xor_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTensor<Se...
  function bitwise_left_shift (line 463) | fn bitwise_left_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> Int...
  function bitwise_right_shift (line 467) | fn bitwise_right_shift(lhs: IntTensor<Self>, rhs: IntTensor<Self>) -> In...
  function bitwise_left_shift_scalar (line 471) | fn bitwise_left_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntTe...
  function bitwise_right_shift_scalar (line 475) | fn bitwise_right_shift_scalar(lhs: IntTensor<Self>, rhs: Scalar) -> IntT...
  function int_cast (line 479) | fn int_cast(tensor: IntTensor<Self>, dtype: IntDType) -> IntTensor<Self> {
  function int_unfold (line 493) | fn int_unfold(

FILE: crates/burn-tch/src/ops/module.rs
  function embedding (line 12) | fn embedding(weights: TchTensor, indices: TchTensor) -> TchTensor {
  function embedding_backward (line 30) | fn embedding_backward(weights: TchTensor, output: TchTensor, indices: Tc...
  function conv1d (line 62) | fn conv1d(
  function conv2d (line 81) | fn conv2d(
  function conv3d (line 100) | fn conv3d(
  function deform_conv2d (line 119) | fn deform_conv2d(
  function deform_conv2d_backward (line 130) | fn deform_conv2d_backward(
  function conv_transpose1d (line 142) | fn conv_transpose1d(
  function conv_transpose2d (line 162) | fn conv_transpose2d(
  function conv_transpose3d (line 182) | fn conv_transpose3d(
  function avg_pool1d (line 202) | fn avg_pool1d(
  function avg_pool2d (line 221) | fn avg_pool2d(
  function avg_pool2d_backward (line 242) | fn avg_pool2d_backward(
  function max_pool1d (line 265) | fn max_pool1d(
  function max_pool1d_with_indices (line 285) | fn max_pool1d_with_indices(
  function max_pool2d (line 305) | fn max_pool2d(
  function max_pool2d_with_indices (line 325) | fn max_pool2d_with_indices(
  function max_pool2d_with_indices_backward (line 345) | fn max_pool2d_with_indices_backward(
  function adaptive_avg_pool2d (line 369) | fn adaptive_avg_pool2d(x: TchTensor, output_size: [usize; 2]) -> TchTens...
  function adaptive_avg_pool2d_backward (line 375) | fn adaptive_avg_pool2d_backward(x: TchTensor, grad: TchTensor) -> TchTen...
  function adaptive_avg_pool1d (line 381) | fn adaptive_avg_pool1d(x: TchTensor, output_size: usize) -> TchTensor {
  function interpolate (line 387) | fn interpolate(
  function interpolate_backward (line 413) | fn interpolate_backward(
  function attention (line 456) | fn attention(

FILE: crates/burn-tch/src/ops/qtensor.rs
  function q_from_data (line 11) | fn q_from_data(_data: TensorData, _device: &LibTorchDevice) -> Quantized...
  function quantize (line 15) | fn quantize(
  function quantize_dynamic (line 23) | fn quantize_dynamic(
  function dequantize (line 30) | fn dequantize(_tensor: QuantizedTensor<Self>) -> FloatTensor<Self> {
  function q_device (line 34) | fn q_device(_tensor: &QuantizedTensor<Self>) -> LibTorchDevice {
  function q_to_device (line 38) | fn q_to_device(
  function q_reshape (line 45) | fn q_reshape(_tensor: QuantizedTensor<Self>, _shape: Shape) -> Quantized...
  function q_into_data (line 49) | async fn q_into_data(_tensor: QuantizedTensor<Self>) -> Result<TensorDat...
  function q_swap_dims (line 52) | fn q_swap_dims(
  function q_permute (line 60) | fn q_permute(_tensor: QuantizedTensor<Self>, _axes: &[usize]) -> Quantiz...
  function q_flip (line 64) | fn q_flip(_tensor: QuantizedTensor<Self>, _axes: &[usize]) -> QuantizedT...
  function q_select (line 68) | fn q_select(
  function q_slice (line 76) | fn q_slice(
  function q_argmax (line 83) | fn q_argmax(_tensor: QuantizedTensor<Self>, _dim: usize) -> IntTensor<Se...
  function q_argmin (line 87) | fn q_argmin(_tensor: QuantizedTensor<Self>, _dim: usize) -> IntTensor<Se...
  function q_max_dim_with_indices (line 91) | fn q_max_dim_with_indices(
  function q_max_dim (line 98) | fn q_max_dim(_tensor: QuantizedTensor<Self>, _dim: usize) -> QuantizedTe...
  function q_min_dim (line 102) | fn q_min_dim(_tensor: QuantizedTensor<Self>, _dim: usize) -> QuantizedTe...
  function q_min_dim_with_indices (line 106) | fn q_min_dim_with_indices(
  function q_expand (line 113) | fn q_expand(_tensor: QuantizedTensor<Self>, _shape: Shape) -> QuantizedT...
  function q_sort (line 117) | fn q_sort(
  function q_sort_with_indices (line 125) | fn q_sort_with_indices(
  function q_argsort (line 133) | fn q_argsort(

FILE: crates/burn-tch/src/ops/tensor.rs
  function float_from_data (line 11) | fn float_from_data(data: TensorData, device: &LibTorchDevice) -> TchTens...
  function float_random (line 21) | fn float_random(
  function float_repeat_dim (line 50) | fn float_repeat_dim(tensor: TchTensor, dim: usize, times: usize) -> TchT...
  function float_zeros (line 54) | fn float_zeros(shape: Shape, device: &LibTorchDevice, dtype: FloatDType)...
  function float_ones (line 61) | fn float_ones(shape: Shape, device: &LibTorchDevice, dtype: FloatDType) ...
  function float_into_data (line 68) | async fn float_into_data(tensor: TchTensor) -> Result<TensorData, Execut...
  function float_device (line 92) | fn float_device(tensor: &TchTensor) -> LibTorchDevice {
  function float_to_device (line 96) | fn float_to_device(tensor: TchTensor, device: &LibTorchDevice) -> TchTen...
  function float_empty (line 100) | fn float_empty(shape: Shape, device: &LibTorchDevice, dtype: FloatDType)...
  function float_add (line 109) | fn float_add(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function float_add_scalar (line 113) | fn float_add_scalar(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function float_sub (line 122) | fn float_sub(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function float_sub_scalar (line 126) | fn float_sub_scalar(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function float_mul (line 135) | fn float_mul(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function float_mul_scalar (line 139) | fn float_mul_scalar(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function float_div (line 148) | fn float_div(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function float_div_scalar (line 152) | fn float_div_scalar(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function float_remainder (line 161) | fn float_remainder(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function float_remainder_scalar (line 165) | fn float_remainder_scalar(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function float_matmul (line 174) | fn float_matmul(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function float_cross (line 179) | fn float_cross(lhs: TchTensor, rhs: TchTensor, dim: usize) -> TchTensor {
  function float_recip (line 184) | fn float_recip(tensor: TchTensor) -> TchTensor {
  function float_swap_dims (line 188) | fn float_swap_dims(tensor: TchTensor, dim1: usize, dim2: usize) -> TchTe...
  function float_reshape (line 192) | fn float_reshape(tensor: TchTensor, shape: Shape) -> TchTensor {
  function float_gather (line 196) | fn float_gather(dim: usize, tensor: TchTensor, indices: TchTensor) -> Tc...
  function float_scatter_add (line 200) | fn float_scatter_add(
  function float_select (line 209) | fn float_select(tensor: TchTensor, dim: usize, indices: TchTensor) -> Tc...
  function float_select_add (line 213) | fn float_select_add(
  function float_slice (line 222) | fn float_slice(tensor: TchTensor, slices: &[burn_backend::Slice]) -> Tch...
  function float_slice_assign (line 226) | fn float_slice_assign(
  function float_mask_where (line 234) | fn float_mask_where(tensor: TchTensor, mask: TchTensor, value: TchTensor...
  function float_mask_fill (line 240) | fn float_mask_fill(tensor: TchTensor, mask: TchTensor, value: Scalar) ->...
  function float_equal (line 249) | fn float_equal(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function float_equal_elem (line 253) | fn float_equal_elem(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function float_greater (line 257) | fn float_greater(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function float_greater_elem (line 261) | fn float_greater_elem(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function float_greater_equal (line 265) | fn float_greater_equal(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function float_greater_equal_elem (line 269) | fn float_greater_equal_elem(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function float_lower (line 273) | fn float_lower(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function float_lower_elem (line 277) | fn float_lower_elem(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function float_lower_equal (line 281) | fn float_lower_equal(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function float_lower_equal_elem (line 285) | fn float_lower_equal_elem(lhs: TchTensor, rhs: Scalar) -> TchTensor {
  function float_mean (line 289) | fn float_mean(tensor: TchTensor) -> TchTensor {
  function float_sum (line 293) | fn float_sum(tensor: TchTensor) -> TchTensor {
  function float_sum_dim (line 297) | fn float_sum_dim(tensor: TchTensor, dim: usize) -> TchTensor {
  function float_mean_dim (line 301) | fn float_mean_dim(tensor: TchTensor, dim: usize) -> TchTensor {
  function float_cumsum (line 305) | fn float_cumsum(tensor: TchTensor, dim: usize) -> TchTensor {
  function float_cumprod (line 309) | fn float_cumprod(tensor: TchTensor, dim: usize) -> TchTensor {
  function float_cummin (line 313) | fn float_cummin(tensor: TchTensor, dim: usize) -> TchTensor {
  function float_cummax (line 317) | fn float_cummax(tensor: TchTensor, dim: usize) -> TchTensor {
  function float_prod (line 321) | fn float_prod(tensor: TchTensor) -> TchTensor {
  function float_prod_dim (line 325) | fn float_prod_dim(tensor: TchTensor, dim: usize) -> TchTensor {
  function float_argmax (line 329) | fn float_argmax(tensor: TchTensor, dim: usize) -> TchTensor {
  function float_argmin (line 333) | fn float_argmin(tensor: TchTensor, dim: usize) -> TchTensor {
  function float_max_dim (line 337) | fn float_max_dim(tensor: TchTensor, dim: usize) -> TchTensor {
  function float_max_dim_with_indices (line 341) | fn float_max_dim_with_indices(tensor: TchTensor, dim: usize) -> (TchTens...
  function float_min_dim (line 345) | fn float_min_dim(tensor: TchTensor, dim: usize) -> TchTensor {
  function float_min_dim_with_indices (line 349) | fn float_min_dim_with_indices(tensor: TchTensor, dim: usize) -> (TchTens...
  function float_exp (line 353) | fn float_exp(tensor: TchTensor) -> TchTensor {
  function float_log (line 357) | fn float_log(tensor: TchTensor) -> TchTensor {
  function float_log1p (line 361) | fn float_log1p(tensor: TchTensor) -> TchTensor {
  function float_powf_scalar_impl (line 365) | fn float_powf_scalar_impl(tensor: TchTensor, value: Scalar) -> TchTensor {
  function float_sqrt (line 372) | fn float_sqrt(tensor: TchTensor) -> TchTensor {
  function float_abs (line 376) | fn float_abs(tensor: TchTensor) -> TchTensor {
  function float_cos (line 380) | fn float_cos(tensor: TchTensor) -> TchTensor {
  function float_cosh (line 384) | fn float_cosh(tensor: TchTensor) -> TchTensor {
  function float_sin (line 388) | fn float_sin(tensor: TchTensor) -> TchTensor {
  function float_sinh (line 392) | fn float_sinh(tensor: TchTensor) -> TchTensor {
  function float_tan (line 396) | fn float_tan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_tanh (line 400) | fn float_tanh(tensor: TchTensor) -> TchTensor {
  function float_acos (line 404) | fn float_acos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_acosh (line 408) | fn float_acosh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asin (line 412) | fn float_asin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_asinh (line 416) | fn float_asinh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan (line 420) | fn float_atan(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atanh (line 424) | fn float_atanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
  function float_atan2 (line 428) | fn float_atan2(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatT...
  function float_round (line 432) | fn float_round(tensor: TchTensor) -> TchTensor {
  function float_floor (line 436) | fn float_floor(tensor: TchTensor) -> TchTensor {
  function float_ceil (line 440) | fn float_ceil(tensor: TchTensor) -> TchTensor {
  function float_trunc (line 444) | fn float_trunc(tensor: TchTensor) -> TchTensor {
  function float_erf (line 448) | fn float_erf(tensor: TchTensor) -> TchTensor {
  function float_cat (line 452) | fn float_cat(tensors: Vec<TchTensor>, dim: usize) -> TchTensor {
  function float_clamp_min (line 456) | fn float_clamp_min(tensor: TchTensor, min: Scalar) -> TchTensor {
  function float_clamp_max (line 460) | fn float_clamp_max(tensor: TchTensor, max: Scalar) -> TchTensor {
  function float_clamp (line 464) | fn float_clamp(tensor: TchTensor, min: Scalar, max: Scalar) -> TchTensor {
  function float_into_int (line 468) | fn float_into_int(tensor: TchTensor) -> TchTensor {
  function float_powf (line 473) | fn float_powf(lhs: TchTensor, rhs: TchTensor) -> TchTensor {
  function float_permute (line 477) | fn float_permute(tensor: TchTensor, axes: &[usize]) -> TchTensor {
  function float_flip (line 481) | fn float_flip(tensor: TchTensor, axes: &[usize]) -> TchTensor {
  function float_sign (line 485) | fn float_sign(tensor: TchTensor) -> TchTensor {
  function float_expand (line 489) | fn float_expand(tensor: TchTensor, shape: Shape) -> TchTensor {
  function float_sort (line 493) | fn float_sort(tensor: TchTensor, dim: usize, descending: bool) -> TchTen...
  function float_sort_with_indices (line 497) | fn float_sort_with_indices(
  function float_argsort (line 505) | fn float_argsort(tensor: TchTensor, dim: usize, descending: bool) -> Int...
  function float_cast (line 509) | fn float_cast(tensor: TchTensor, dtype: FloatDType) -> TchTensor {
  function float_unfold (line 523) | fn float_unfold(
  function float_is_nan (line 532) | fn float_is_nan(tensor: FloatTensor<Self>) -> BoolTensor<Self> {
  function float_is_inf (line 536) | fn float_is_inf(tensor: FloatTensor<Self>) -> BoolTensor<Self> {

FILE: crates/burn-tch/src/tensor.rs
  type StorageRef (line 10) | pub type StorageRef = Arc<*mut c_void>;
  type Storage (line 14) | pub enum Storage {
    method can_mut (line 31) | pub fn can_mut(&self) -> bool {
    method buffer_ref (line 44) | pub fn buffer_ref(&self) -> &StorageRef {
  type TchTensor (line 59) | pub struct TchTensor {
    method scheme (line 95) | fn scheme(&self) -> &burn_backend::quantization::QuantScheme {
    method fmt (line 101) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method new (line 155) | pub fn new(tensor: tch::Tensor) -> Self {
    method from_existing (line 168) | pub fn from_existing(tensor: tch::Tensor, storage_parent: Storage) -> ...
    method partial (line 202) | pub fn partial(tensor: tch::Tensor, storage_parent: Storage) -> Self {
    method can_mut (line 223) | pub fn can_mut(&self) -> bool {
    method mut_ops (line 230) | pub fn mut_ops<F: Fn(&mut tch::Tensor) -> tch::Tensor>(
    method unary_ops (line 243) | pub fn unary_ops<FOwn, FRef>(self, fown: FOwn, fref: FRef) -> TchTensor
    method binary_ops_tensor (line 256) | pub fn binary_ops_tensor<FLMut, FRMut, FRef>(
    method from_data (line 345) | pub fn from_data<E: TchElement>(data: TensorData, device: tch::Device)...
    method empty (line 365) | pub fn empty<E: TchElement>(shape: Shape, device: LibTorchDevice) -> S...
  method dtype (line 68) | fn dtype(&self) -> DType {
  method shape (line 85) | fn shape(&self) -> Shape {
  method rank (line 89) | fn rank(&self) -> usize {
  type IntoKind (line 106) | pub(crate) trait IntoKind {
    method try_into_kind (line 107) | fn try_into_kind(self) -> Result<tch::Kind, tch::TchError>;
    method into_kind (line 108) | fn into_kind(self) -> tch::Kind
    method try_into_kind (line 117) | fn try_into_kind(self) -> Result<tch::Kind, tch::TchError> {
    method try_into_kind (line 124) | fn try_into_kind(self) -> Result<tch::Kind, tch::TchError> {
    method try_into_kind (line 131) | fn try_into_kind(self) -> Result<tch::Kind, tch::TchError> {
  method clone (line 303) | fn clone(&self) -> Self {
  type TchShape (line 313) | pub struct TchShape {
    method from (line 319) | fn from(shape: Shape) -> Self {
    method from (line 327) | fn from(shape: &[usize]) -> Self {
  type Error (line 376) | type Error = tch::TchError;
  function try_from (line 377) | fn try_from(tensor: &TchTensor) -> Result<Self, Self::Error> {
  function ptr_to_string (line 395) | unsafe fn ptr_to_string(ptr: *mut libc::c_char) -> Option<String> {
  function f_copy_data (line 408) | fn f_copy_data<T: TchElement>(
  type B (line 444) | type B = crate::LibTorch<f32>;
  function should_have_bf16_kind (line 447) | fn should_have_bf16_kind() {
  function should_support_dtypes (line 460) | fn should_support_dtypes() {
  function should_support_from_bf16 (line 485) | fn should_support_from_bf16() {
  function dummy_cuda_dependency (line 503) | pub fn dummy_cuda_dependency();

FILE: crates/burn-tensor-testgen/src/lib.rs
  type AttributeArgs (line 10) | struct AttributeArgs {
  method parse (line 15) | fn parse(input: ParseStream) -> syn::Result<Self> {
  function might_panic (line 45) | pub fn might_panic(args: TokenStream, input: TokenStream) -> TokenStream {

FILE: crates/burn-tensor/src/device.rs
  type DevicePolicy (line 30) | pub(crate) struct DevicePolicy {
    method float_dtype (line 39) | pub(crate) fn float_dtype(&self) -> Option<FloatDType> {
    method int_dtype (line 44) | pub(crate) fn int_dtype(&self) -> Option<IntDType> {
    method set_float_dtype (line 49) | pub(crate) fn set_float_dtype(&mut self, dtype: FloatDType) {
    method set_int_dtype (line 54) | pub(crate) fn set_int_dtype(&mut self, dtype: IntDType) {
  type RegistryKey (line 60) | type RegistryKey = (DeviceId, TypeId);
  type DevicePolicyRegistry (line 77) | struct DevicePolicyRegistry;
    method get (line 83) | fn get<D: DeviceOps>(device: &D) -> Arc<DevicePolicy> {
    method update (line 98) | fn update<D: DeviceOps>(device: &D, update_fn: impl FnOnce(&mut Device...
    method key (line 112) | fn key<D: Device>(device: &D) -> RegistryKey {
  function get_device_policy (line 121) | pub(crate) fn get_device_policy<D: DeviceOps>(device: &D) -> Arc<DeviceP...
  type DeviceError (line 131) | pub enum DeviceError {
    method unsupported_dtype (line 145) | pub fn unsupported_dtype<D: DeviceOps>(device: &D, dtype: DType) -> Se...
  function check_dtype_support (line 153) | fn check_dtype_support<B: Backend>(
  function set_default_dtypes (line 191) | pub fn set_default_dtypes<B: Backend>(
  function set_default_float_dtype (line 227) | pub fn set_default_float_dtype<B: Backend>(
  function set_default_int_dtype (line 260) | pub fn set_default_int_dtype<B: Backend>(
  function set_default_dtypes_unchecked (line 272) | fn set_default_dtypes_unchecked<D: DeviceOps>(
  function set_default_float_dtype_unchecked (line 283) | fn set_default_float_dtype_unchecked<D: DeviceOps>(device: &D, dtype: Fl...
  function set_default_int_dtype_unchecked (line 289) | fn set_default_int_dtype_unchecked<D: DeviceOps>(device: &D, dtype: IntD...
  function clear_registry (line 301) | fn clear_registry() {
  type TestDeviceA (line 306) | pub struct TestDeviceA {
  method from_id (line 311) | fn from_id(device_id: DeviceId) -> Self {
  method to_id (line 317) | fn to_id(&self) -> DeviceId {
  method device_count (line 324) | fn device_count(_type_id: u16) -> usize {
  type TestDeviceB (line 332) | pub struct TestDeviceB {
  method from_id (line 337) | fn from_id(device_id: DeviceId) -> Self {
  method to_id (line 343) | fn to_id(&self) -> DeviceId {
  method device_count (line 350) | fn device_count(_type_id: u16) -> usize {
  function default_policy_is_created_and_shared (line 359) | fn default_policy_is_created_and_shared() {
  function updated_policy_is_shared (line 377) | fn updated_policy_is_shared() {
  function policy_is_device_id_specific (line 396) | fn policy_is_device_id_specific() {
  function policy_is_device_type_specific (line 416) | fn policy_is_device_type_specific() {
  function updating_policy_should_not_affect_snapshot (line 435) | fn updating_policy_should_not_affect_snapshot() {
  function set_default_dtypes_overwrites_fields (line 453) | fn set_default_dtypes_overwrites_fields() {

FILE: crates/burn-tensor/src/tensor/activation/base.rs
  function relu (line 10) | pub fn relu<const D: usize, B: Backend>(tensor: Tensor<B, D>) -> Tensor<...
  function leaky_relu (line 38) | pub fn leaky_relu<const D: usize, B: Backend>(
  function gelu (line 71) | pub fn gelu<const D: usize, B: Backend>(tensor: Tensor<B, D>) -> Tensor<...
  function gelu_approximate (line 90) | pub fn gelu_approximate<const D: usize, B: Backend>(tensor: Tensor<B, D>...
  function prelu (line 126) | pub fn prelu<const D: usize, B: Backend>(
  function softmax (line 171) | pub fn softmax<const D: usize, B: Backend>(tensor: Tensor<B, D>, dim: us...
  function softmin (line 198) | pub fn softmin<const D: usize, B: Backend>(tensor: Tensor<B, D>, dim: us...
  function softplus (line 216) | pub fn softplus<const D: usize, B: Backend>(tensor: Tensor<B, D>, beta: ...
  function quiet_softmax (line 246) | pub fn quiet_softmax<const D: usize, B: Backend>(tensor: Tensor<B, D>, d...
  function log_softmax (line 278) | pub fn log_softmax<const D: usize, B: Backend>(tensor: Tensor<B, D>, dim...
  function sigmoid (line 300) | pub fn sigmoid<const D: usize, B: Backend>(tensor: Tensor<B, D>) -> Tens...
  function hard_sigmoid (line 317) | pub fn hard_sigmoid<const D: usize, B: Backend>(
  function log_sigmoid (line 340) | pub fn log_sigmoid<const D: usize, B: Backend>(tensor: Tensor<B, D>) -> ...
  function silu (line 357) | pub fn silu<const D: usize, B: Backend>(tensor: Tensor<B, D>) -> Tensor<...
  function hard_swish (line 375) | pub fn hard_swish<const D: usize, B: Backend>(tensor: Tensor<B, D>) -> T...
  function mish (line 396) | pub fn mish<const D: usize, B: Backend>(tensor: Tensor<B, D>) -> Tensor<...
  function tanh (line 401) | pub fn tanh<const D: usize, B: Backend>(tensor: Tensor<B, D>) -> Tensor<...
  function elu (line 423) | pub fn elu<const D: usize, B: Backend>(tensor: Tensor<B, D>, alpha: f64)...
  function celu (line 452) | pub fn celu<const D: usize, B: Backend>(tensor: Tensor<B, D>, alpha: f64...
  function selu (line 484) | pub fn selu<const D: usize, B: Backend>(tensor: Tensor<B, D>) -> Tensor<...
  function thresholded_relu (line 514) | pub fn thresholded_relu<const D: usize, B: Backend>(
  function glu (line 534) | pub fn glu<const D: usize, B: Backend>(tensor: Tensor<B, D>, dim: usize)...
  function softsign (line 560) | pub fn softsign<const D: usize, B: Backend>(tensor: Tensor<B, D>) -> Ten...
  function hard_shrink (line 585) | pub fn hard_shrink<const D: usize, B: Backend>(tensor: Tensor<B, D>, lam...
  function soft_shrink (line 611) | pub fn soft_shrink<const D: usize, B: Backend>(tensor: Tensor<B, D>, lam...
  function shrink (line 637) | pub fn shrink<const D: usize, B: Backend>(

FILE: crates/burn-tensor/src/tensor/api/autodiff.rs
  function backward (line 7) | pub fn backward(&self) -> B::Gradients {
  function grad (line 16) | pub fn grad(&self, grads: &B::Gradients) -> Option<Tensor<B::InnerBacken...
  function grad_remove (line 28) | pub fn grad_remove(&self, grads: &mut B::Gradients) -> Option<Tensor<B::...
  function grad_replace (line 43) | pub fn grad_replace(&self, grads: &mut B::Gradients, grad: Tensor<B::Inn...
  function inner (line 59) | pub fn inner(self) -> Tensor<B::InnerBackend, D, K::InnerKind> {
  function from_inner (line 72) | pub fn from_inner(inner: Tensor<B::InnerBackend, D, K::InnerKind>) -> Se...

FILE: crates/burn-tensor/src/tensor/api/base.rs
  type Tensor (line 76) | pub struct Tensor<B, const D: usize, K = Float>
  function from (line 90) | fn from(value: T) -> Self {
  function inplace (line 111) | pub fn inplace<F: FnOnce(Self) -> Self>(&mut self, func: F) {
  function into_primitive (line 120) | pub fn into_primitive(self) -> K::Primitive {
  function from_primitive (line 125) | pub fn from_primitive(tensor: K::Primitive) -> Self {
  function rank (line 130) | pub fn rank(&self) -> usize {
  function dtype (line 139) | pub fn dtype(&self) -> DType {
  function empty (line 161) | pub fn empty<S: Into<Shape>>(shape: S, options: impl Into<TensorCreation...
  function zeros (line 184) | pub fn zeros<S: Into<Shape>>(shape: S, options: impl Into<TensorCreation...
  function zeros_like (line 208) | pub fn zeros_like(&self) -> Self {
  function ones (line 227) | pub fn ones<S: Into<Shape>>(shape: S, options: impl Into<TensorCreationO...
  function ones_like (line 251) | pub fn ones_like(&self) -> Self {
  function full (line 270) | pub fn full<S: Into<Shape>, E: ElementConversion>(
  function full_like (line 304) | pub fn full_like<E: ElementConversion>(&self, fill_value: E) -> Self {
  function dims (line 328) | pub fn dims(&self) -> [usize; D] {
  function shape (line 346) | pub fn shape(&self) -> Shape {
  function reshape (line 386) | pub fn reshape<const D2: usize, S: ReshapeArgs<D2>>(self, shape: S) -> T...
  function transpose (line 426) | pub fn transpose(self) -> Tensor<B, D, K> {
  function t (line 432) | pub fn t(self) -> Tensor<B, D, K> {
  function swap_dims (line 472) | pub fn swap_dims<Dim1, Dim2>(self, dim1: Dim1, dim2: Dim2) -> Tensor<B, ...
  function permute (line 520) | pub fn permute<Dim>(self, axes: [Dim; D]) -> Tensor<B, D, K>
  function movedim (line 585) | pub fn movedim<S1: MovedimArgs, S2: MovedimArgs>(self, src: S1, dst: S2)...
  function flip (line 656) | pub fn flip<const N: usize>(self, axes: [isize; N]) -> Tensor<B, D, K> {
  function flatten (line 711) | pub fn flatten<const D2: usize>(
  function squeeze (line 756) | pub fn squeeze<const D2: usize>(self) -> Tensor<B, D2, K> {
  function squeeze_dim (line 807) | pub fn squeeze_dim<const D2: usize>(self, dim: usize) -> Tensor<B, D2, K> {
  function squeeze_dims (line 857) | pub fn squeeze_dims<const D2: usize>(self, dims: &[isize]) -> Tensor<B, ...
  function unsqueeze (line 939) | pub fn unsqueeze<const D2: usize>(self) -> Tensor<B, D2, K> {
  function unsqueeze_dim (line 970) | pub fn unsqueeze_dim<const D2: usize>(self, dim: usize) -> Tensor<B, D2,...
  function unsqueeze_dims (line 1009) | pub fn unsqueeze_dims<const D2: usize>(self, axes: &[impl AsIndex]) -> T...
  function roll_dim (line 1080) | pub fn roll_dim<Shift, Dim>(self, shift: Shift, dim: Dim) -> Self
  function unchecked_roll_dim (line 1112) | fn unchecked_roll_dim(self, shift: usize, dim: usize) -> Self {
  function roll (line 1150) | pub fn roll<Shift, Dim>(self, shifts: &[Shift], dims: &[Dim]) -> Self
  function unchecked_roll (line 1227) | fn unchecked_roll(self, shifts: &[usize], dims: &[usize]) -> Self {
  function slice (line 1341) | pub fn slice<S>(self, slices: S) -> Self
  function slice_assign (line 1429) | pub fn slice_assign<S>(self, slices: S, values: Self) -> Self
  function slice_fill (line 1515) | pub fn slice_fill<S, E: ElementConversion>(self, slices: S, value: E) ->...
  function slice_dim (line 1588) | pub fn slice_dim<S>(self, dim: usize, slice: S) -> Self
  function device (line 1602) | pub fn device(&self) -> B::Device {
  function to_device (line 1607) | pub fn to_device(self, device: &B::Device) -> Self {
  function select (line 1633) | pub fn select(self, dim: impl AsIndex, indices: Tensor<B, 1, Int>) -> Se...
  function select_assign (line 1665) | pub fn select_assign(
  function mask_where (line 1709) | pub fn mask_where(self, mask: Tensor<B, D, Bool>, value: Self) -> Self {
  function mask_fill (line 1737) | pub fn mask_fill<E: ElementConversion>(self, mask: Tensor<B, D, Bool>, v...
  function gather (line 1758) | pub fn gather(self, dim: usize, indices: Tensor<B, D, Int>) -> Self {
  function scatter (line 1793) | pub fn scatter(
  function into_data (line 1823) | pub fn into_data(self) -> TensorData {
  function try_into_data (line 1837) | pub fn try_into_data(self) -> Result<TensorData, ExecutionError> {
  function to_data (line 1852) | pub fn to_data(&self) -> TensorData {
  function into_data_async (line 1857) | pub async fn into_data_async(self) -> Result<TensorData, ExecutionError> {
  function to_data_async (line 1862) | pub async fn to_data_async(&self) -> Result<TensorData, ExecutionError> {
  function from_data (line 1867) | pub fn from_data<T>(data: T, device: &B::Device) -> Self
  function from_data_dtype (line 1880) | pub fn from_data_dtype<T>(data: T, device: &B::Device, dtype: DType) -> ...
  function repeat_dim (line 1922) | pub fn repeat_dim(self, dim: usize, times: usize) -> Self {
  function repeat (line 1961) | pub fn repeat(self, sizes: &[usize]) -> Self {
  function equal (line 2005) | pub fn equal(self, other: Self) -> Tensor<B, D, Bool> {
  function not_equal (line 2035) | pub fn not_equal(self, other: Self) -> Tensor<B, D, Bool> {
  function equal_elem (line 2060) | pub fn equal_elem<E: Element>(self, other: E) -> Tensor<B, D, Bool> {
  function not_equal_elem (line 2085) | pub fn not_equal_elem<E: Element>(self, other: E) -> Tensor<B, D, Bool> {
  function cat (line 2116) | pub fn cat(tensors: Vec<Self>, dim: usize) -> Self {
  function stack (line 2170) | pub fn stack<const D2: usize>(tensors: Vec<Tensor<B, D, K>>, dim: usize)...
  function iter_dim (line 2203) | pub fn iter_dim(self, dim: usize) -> DimIter<B, D, K> {
  function narrow (line 2244) | pub fn narrow(self, dim: usize, start: usize, length: usize) -> Self {
  function chunk (line 2306) | pub fn chunk(self, chunks: usize, dim: usize) -> Vec<Self> {
  function split (line 2366) | pub fn split(self, split_size: usize, dim: usize) -> Vec<Self> {
  function split_with_sizes (line 2412) | pub fn split_with_sizes(self, split_sizes: Vec<usize>, dim: usize) -> Ve...
  function any (line 2465) | pub fn any(self) -> Tensor<B, 1, Bool> {
  function any_dim (line 2498) | pub fn any_dim(self, dim: usize) -> Tensor<B, D, Bool> {
  function all (line 2529) | pub fn all(self) -> Tensor<B, 1, Bool> {
  function all_dim (line 2562) | pub fn all_dim(self, dim: usize) -> Tensor<B, D, Bool> {
  function into_scalar (line 2591) | pub fn into_scalar(self) -> K::Elem {
  function try_into_scalar (line 2611) | pub fn try_into_scalar(self) -> Result<K::Elem, ExecutionError> {
  function into_scalar_async (line 2623) | pub async fn into_scalar_async(self) -> Result<K::Elem, ExecutionError> {
  function expand (line 2665) | pub fn expand<const D2: usize, S: BroadcastArgs<D, D2>>(self, shape: S) ...
  function unfold (line 2701) | pub fn unfold<const D2: usize, I: AsIndex>(
  type DimIter (line 2720) | pub struct DimIter<B, const D: usize, K>
  type Item (line 2733) | type Item = Tensor<B, D, K>;
  method next (line 2735) | fn next(&mut self) -> Option<Self::Item> {
  method next_back (line 2751) | fn next_back(&mut self) -> Option<Self::Item> {
  function new (line 2767) | fn new(tensor: Tensor<B, D, K>, dim: usize) -> Self {
  function push_newline_indent (line 2791) | fn push_newline_indent(acc: &mut String, indent: usize) {
  function fmt_inner_tensor (line 2797) | fn fmt_inner_tensor(
  function fmt_outer_tensor (line 2829) | fn fmt_outer_tensor(
  function display_recursive (line 2863) | fn display_recursive(
  type PrintOptions (line 2952) | pub struct PrintOptions {
    method const_default (line 2967) | pub const fn const_default() -> Self {
  method default (line 2977) | fn default() -> Self {
  function set_print_options (line 2983) | pub fn set_print_options(options: PrintOptions) {
  function fmt (line 2996) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type MovedimArgs (line 3033) | pub trait MovedimArgs {
    method into_dim_vec (line 3035) | fn into_dim_vec<const D: usize>(self) -> Vec<usize>;
    method into_dim_vec (line 3039) | fn into_dim_vec<const D: usize>(self) -> Vec<usize> {
    method into_dim_vec (line 3057) | fn into_dim_vec<const D: usize>(self) -> Vec<usize> {
    method into_dim_vec (line 3065) | fn into_dim_vec<const D: usize>(self) -> Vec<usize> {
    method into_dim_vec (line 3077) | fn into_dim_vec<const D: usize>(self) -> Vec<usize> {
  type ReshapeArgs (line 3094) | pub trait ReshapeArgs<const D2: usize>: Debug {
    method into_shape (line 3096) | fn into_shape<const D: usize>(self, source: Shape) -> Shape;
  function into_shape (line 3100) | fn into_shape<const D: usize>(self, source: Shape) -> Shape {
  method into_shape (line 3106) | fn into_shape<const D: usize>(self, source: Shape) -> Shape {
  type BroadcastArgs (line 3112) | pub trait BroadcastArgs<const D1: usize, const D2: usize> {
    method into_shape (line 3114) | fn into_shape(self, shape: &Shape) -> Shape;
  method into_shape (line 3118) | fn into_shape(self, _shape: &Shape) -> Shape {
  function into_shape (line 3125) | fn into_shape(self, shape: &Shape) -> Shape {
  method serialize (line 3164) | fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Er...
  function deserialize (line 3176) | fn deserialize<De: Deserializer<'de>>(deserializer: De) -> Result<Self, ...
  function slice_range_single_dim_leading (line 3192) | fn slice_range_single_dim_leading() {
  function test_negative_slice_indices (line 3225) | fn test_negative_slice_indices() {
  function slice_range_multi_dim (line 3256) | fn slice_range_multi_dim() {
  function slice_range_multi_dim_index (line 3282) | fn slice_range_multi_dim_index() {
  function slice_range_multi_dim_heterogeneous (line 3296) | fn slice_range_multi_dim_heterogeneous() {

FILE: crates/burn-tensor/src/tensor/api/bool.rs
  type TriPart (line 7) | enum TriPart {
  function from_bool (line 45) | pub fn from_bool(data: TensorData, device: &B::Device) -> Self {
  function int (line 68) | pub fn int(self) -> Tensor<B, D, Int> {
  function float (line 91) | pub fn float(self) -> Tensor<B, D> {
  function bool_not (line 110) | pub fn bool_not(self) -> Self {
  function bool_and (line 138) | pub fn bool_and(self, rhs: Tensor<B, D, Bool>) -> Tensor<B, D, Bool> {
  function bool_or (line 166) | pub fn bool_or(self, rhs: Tensor<B, D, Bool>) -> Tensor<B, D, Bool> {
  function bool_xor (line 195) | pub fn bool_xor(self, rhs: Tensor<B, D, Bool>) -> Tensor<B, D, Bool> {
  function nonzero (line 223) | pub fn nonzero(self) -> Vec<Tensor<B, 1, Int>> {
  function nonzero_async (line 234) | pub async fn nonzero_async(self) -> Vec<Tensor<B, 1, Int>> {
  function argwhere (line 273) | pub fn argwhere(self) -> Tensor<B, 2, Int> {
  function argwhere_async (line 284) | pub async fn argwhere_async(self) -> Tensor<B, 2, Int> {
  function tri_mask (line 290) | fn tri_mask<S: Into<Shape>>(
  function triu_mask (line 358) | pub fn triu_mask<S: Into<Shape>>(shape: S, offset: i64, device: &B::Devi...
  function tril_mask (line 392) | pub fn tril_mask<S: Into<Shape>>(shape: S, offset: i64, device: &B::Devi...
  function diag_mask (line 426) | pub fn diag_mask<S: Into<Shape>>(shape: S, offset: i64, device: &B::Devi...

FILE: crates/burn-tensor/src/tensor/api/cartesian_grid.rs
  function cartesian_grid (line 27) | pub fn cartesian_grid<B: Backend, S: Into<Shape>, const D: usize, const ...

FILE: crates/burn-tensor/src/tensor/api/check.rs
  type TensorCheck (line 36) | pub(crate) enum TensorCheck {
    method binary_ops_ew (line 43) | pub(crate) fn binary_ops_ew<B: Backend, const D: usize, K: BasicOps<B>>(
    method into_scalar (line 53) | pub(crate) fn into_scalar<const D: usize>(shape: &Shape) -> Self {
    method dim_ops (line 70) | pub(crate) fn dim_ops<const D: usize>(ops: &str, dim: usize) -> Self {
    method creation_ops (line 84) | pub(crate) fn creation_ops<const D: usize>(ops: &str, dims: &[usize]) ...
    method narrow (line 106) | pub(crate) fn narrow<B: Backend, const D: usize, K: BasicOps<B>>(
    method movedim_args_usize (line 148) | pub(crate) fn movedim_args_usize<const D: usize>(dim: usize) -> Self {
    method movedim_args_i32 (line 166) | pub(crate) fn movedim_args_i32<const D: usize>(dim: i32) -> Self {
    method movedim_args_vec (line 184) | pub(crate) fn movedim_args_vec<const D: usize>(dims: &Vec<usize>) -> S...
    method movedim_args_length (line 216) | pub(crate) fn movedim_args_length(
    method flatten (line 237) | pub(crate) fn flatten<const D1: usize, const D2: usize>(
    method tri (line 283) | pub(crate) fn tri<const D: usize>() -> Self {
    method squeeze (line 298) | pub(crate) fn squeeze<const D2: usize>(dim: usize, tensor_dims: &[usiz...
    method squeeze_dims_input (line 323) | pub(crate) fn squeeze_dims_input<const D2: usize>(
    method squeeze_dims_len (line 338) | pub(crate) fn squeeze_dims_len<const D2: usize>(new_dims_len: usize) -...
    method unsqueeze (line 362) | pub(crate) fn unsqueeze<const D1: usize, const D2: usize>() -> Self {
    method unsqueeze_dim (line 376) | pub(crate) fn unsqueeze_dim<const D1: usize, const D2: usize>(dim: usi...
    method unsqueeze_dims (line 408) | pub(crate) fn unsqueeze_dims<const D: usize>(dim: isize) -> Self {
    method one_hot_tensor (line 423) | pub(crate) fn one_hot_tensor<B: Backend, const D: usize, K: Ordered<B>>(
    method one_hot_tensor_rank (line 450) | pub(crate) fn one_hot_tensor_rank<const D: usize, const D2: usize>() -...
    method swap_dims (line 464) | pub(crate) fn swap_dims<const D: usize>(dim1: usize, dim2: usize) -> S...
    method permute (line 480) | pub(crate) fn permute<const D: usize>(axes: [usize; D]) -> Self {
    method flip (line 506) | pub(crate) fn flip(rank: usize, axes: &[usize]) -> Self {
    method matmul (line 534) | pub(crate) fn matmul<B: Backend, const D: usize, K>(
    method cross (line 572) | pub(crate) fn cross<B: Backend, const D: usize, K>(
    method stack (line 628) | pub(crate) fn stack<B: Backend, const D1: usize, K: BasicOps<B>, const...
    method cat (line 682) | pub(crate) fn cat<B: Backend, const D: usize, K: BasicOps<B>>(
    method slice (line 733) | pub(crate) fn slice<const R: usize>(shape: &Shape, slices: &[Slice]) -...
    method slice_assign (line 792) | pub(crate) fn slice_assign<const R: usize>(
    method check_dim (line 867) | pub(crate) fn check_dim<const D: usize>(dim: usize) -> Self {
    method gather (line 882) | pub(crate) fn gather<const D: usize>(dim: usize, shape: &Shape, shape_...
    method scatter (line 886) | pub(crate) fn scatter<const D: usize>(
    method select (line 913) | pub(crate) fn select<const D: usize>(dim: usize) -> Self {
    method take (line 917) | pub(crate) fn take<const D: usize, const DI: usize, const DO: usize>(d...
    method diag (line 936) | pub(crate) fn diag<const D: usize, const DO: usize>() -> Self {
    method select_assign (line 964) | pub(crate) fn select_assign<const D: usize>(
    method check_select_basic (line 987) | fn check_select_basic<const D: usize>(mut check: Self, ops: &str, dim:...
    method check_gather_scatter_indices (line 999) | fn check_gather_scatter_indices<const D: usize>(
    method check_prelu_shape (line 1040) | pub(crate) fn check_prelu_shape<const D: usize>(
    method aggregate_dim (line 1079) | pub(crate) fn aggregate_dim<const D: usize>(ops: &str, dim: usize) -> ...
    method sort_dim (line 1094) | pub(crate) fn sort_dim<const D: usize>(ops: &str, dim: usize) -> Self {
    method split (line 1109) | pub(crate) fn split<const D: usize>(
    method split_with_sizes (line 1138) | pub(crate) fn split_with_sizes<const D: usize>(
    method register (line 1172) | fn register(self, ops: &str, error: TensorError) -> Self {
    method binary_ops_ew_shape (line 1188) | pub(crate) fn binary_ops_ew_shape<const D: usize>(
    method binary_ops_device (line 1224) | fn binary_ops_device<Device: PartialEq + core::fmt::Debug>(
    method expand (line 1242) | pub fn expand<const D1: usize, const D2: usize>(ops: &str, shape: &Sha...
    method unfold (line 1288) | pub fn unfold<const D1: usize, const D2: usize>(
    method conv (line 1311) | pub fn conv<const D1: usize, const D2: usize>(
    method conv_transpose (line 1331) | pub fn conv_transpose<const D1: usize, const D2: usize>(
    method is_square (line 1350) | pub fn is_square<const D: usize>(ops: &str, shape: &Shape) -> Self {
    method lu_decomposition_pivot (line 1365) | pub fn lu_decomposition_pivot<B: Backend>(pivot: FloatElem<B>) -> Self {
  type FailedTensorCheck (line 1378) | pub(crate) struct FailedTensorCheck {
    method format (line 1385) | pub(crate) fn format(self) -> String {
  type TensorError (line 1396) | struct TensorError {
    method new (line 1402) | pub(crate) fn new<S: Into<String>>(description: S) -> Self {
    method details (line 1409) | pub(crate) fn details<S: Into<String>>(mut self, details: S) -> Self {
    method format (line 1414) | fn format(self, number: usize) -> String {
  function unwrap_shape_reshape (line 1443) | pub(crate) fn unwrap_shape_reshape(result: Result<Shape, burn_std::Metad...
  function index_range_exceed_dimension (line 1464) | fn index_range_exceed_dimension() {
  function index_range_exceed_number_of_dimensions (line 1471) | fn index_range_exceed_number_of_dimensions() {
  function binary_ops_shapes_no_broadcast (line 1478) | fn binary_ops_shapes_no_broadcast() {
  function binary_ops_shapes_with_broadcast (line 1488) | fn binary_ops_shapes_with_broadcast() {
  function binary_ops_devices (line 1499) | fn binary_ops_devices() {
  function movedim_args_out_of_bounds (line 1510) | fn movedim_args_out_of_bounds() {
  function movedim_args_i32 (line 1515) | fn movedim_args_i32() {
  function movedim_args_too_negative (line 1521) | fn movedim_args_too_negative() {
  function movedim_args_vec_out_of_bounds (line 1527) | fn movedim_args_vec_out_of_bounds() {
  function movedim_args_vec_duplicates (line 1533) | fn movedim_args_vec_duplicates() {
  function movedim_args_length (line 1539) | fn movedim_args_length() {
  function unsqueeze_dim_same_rank (line 1548) | fn unsqueeze_dim_same_rank() {

FILE: crates/burn-tensor/src/tensor/api/float.rs
  constant DEFAULT_RTOL (line 19) | pub const DEFAULT_RTOL: f64 = 1e-5;
  constant DEFAULT_ATOL (line 22) | pub const DEFAULT_ATOL: f64 = 1e-8;
  function exp (line 32) | pub fn exp(self) -> Self {
  function log (line 42) | pub fn log(self) -> Self {
  function log1p (line 52) | pub fn log1p(self) -> Self {
  function erf (line 71) | pub fn erf(self) -> Self {
  function recip (line 82) | pub fn recip(self) -> Self {
  function square (line 92) | pub fn square(self) -> Self {
  function sqrt (line 100) | pub fn sqrt(self) -> Self {
  function cos (line 110) | pub fn cos(self) -> Self {
  function sin (line 120) | pub fn sin(self) -> Self {
  function tan (line 130) | pub fn tan(self) -> Self {
  function cosh (line 154) | pub fn cosh(self) -> Self {
  function sinh (line 178) | pub fn sinh(self) -> Self {
  function tanh (line 202) | pub fn tanh(self) -> Self {
  function asin (line 226) | pub fn asin(self) -> Self {
  function asinh (line 250) | pub fn asinh(self) -> Self {
  function acos (line 274) | pub fn acos(self) -> Self {
  function acosh (line 298) | pub fn acosh(self) -> Self {
  function atan (line 322) | pub fn atan(self) -> Self {
  function atanh (line 346) | pub fn atanh(self) -> Self {
  function atan2 (line 371) | pub fn atan2(self, other: Self) -> Self {
  function deg2rad (line 384) | pub fn deg2rad(self) -> Self {
  function rad2deg (line 394) | pub fn rad2deg(self) -> Self {
  function round (line 402) | pub fn round(self) -> Self {
  function floor (line 409) | pub fn floor(self) -> Self {
  function ceil (line 416) | pub fn ceil(self) -> Self {
  function from_floats (line 436) | pub fn from_floats<A: Into<TensorData>>(floats: A, device: &B::Device) -...
  function int (line 455) | pub fn int(self) -> Tensor<B, D, Int> {
  function random_like (line 461) | pub fn random_like(&self, distribution: Distribution) -> Self {
  function var (line 471) | pub fn var(self, dim: usize) -> Self {
  function var_bias (line 476) | pub fn var_bias(self, dim: usize) -> Self {
  function var_mean (line 481) | pub fn var_mean(self, dim: usize) -> (Self, Self) {
  function var_mean_bias (line 488) | pub fn var_mean_bias(self, dim: usize) -> (Self, Self) {
  function median (line 548) | pub fn median(self, dim: usize) -> Self {
  function median_with_indices (line 592) | pub fn median_with_indices(self, dim: usize) -> (Self, Tensor<B, D, Int>) {
  function cast (line 605) | pub fn cast<F: Into<FloatDType>>(self, dtype: F) -> Tensor<B, D> {
  function detach (line 624) | pub fn detach(self) -> Self {
  function require_grad (line 633) | pub fn require_grad(self) -> Self {
  function is_require_grad (line 638) | pub fn is_require_grad(&self) -> bool {
  function set_require_grad (line 649) | pub fn set_require_grad(self, require_grad: bool) -> Self {
  function relu (line 662) | pub(crate) fn relu(self) -> Self {
  function cov (line 672) | pub fn cov(self, dim: usize, correction_factor: usize) -> Tensor<B, D> {
  function quantize (line 692) | pub fn quantize(
  function quantize_dynamic (line 718) | pub fn quantize_dynamic(self, scheme: &QuantScheme) -> Tensor<B, D> {
  function dequantize (line 732) | pub fn dequantize(self) -> Tensor<B, D> {
  function is_close (line 772) | pub fn is_close(self, other: Self, rtol: Option<f64>, atol: Option<f64>)...
  function all_close (line 836) | pub fn all_close(self, other: Self, rtol: Option<f64>, atol: Option<f64>...
  function is_nan (line 863) | pub fn is_nan(self) -> Tensor<B, D, Bool> {
  function contains_nan (line 891) | pub fn contains_nan(self) -> Tensor<B, 1, Bool> {
  function is_inf (line 920) | pub fn is_inf(self) -> Tensor<B, D, Bool> {
  function is_finite (line 945) | pub fn is_finite(self) -> Tensor<B, D, Bool> {
  function grid_sample_2d (line 979) | pub fn grid_sample_2d(
  function cross (line 1004) | pub fn cross<Dim: AsIndex>(self, other: Tensor<B, D>, dim: Dim) -> Tenso...
  function powf (line 1035) | pub fn powf(self, other: Self) -> Self {
  function powf_scalar (line 1072) | pub fn powf_scalar<E: ElementConversion>(self, other: E) -> Self {

FILE: crates/burn-tensor/src/tensor/api/fmod.rs
  function fmod (line 42) | pub fn fmod(self, other: Self) -> Self {
  function fmod_scalar (line 94) | pub fn fmod_scalar(self, scalar: f32) -> Self {

FILE: crates/burn-tensor/src/tensor/api/int.rs
  function arange (line 20) | pub fn arange(range: Range<i64>, device: &B::Device) -> Self {
  function arange_step (line 30) | pub fn arange_step(range: Range<i64>, step: usize, device: &B::Device) -...
  function from_ints (line 53) | pub fn from_ints<A: Into<TensorData>>(ints: A, device: &B::Device) -> Se...
  function float (line 72) | pub fn float(self) -> Tensor<B, D, Float> {
  function cartesian_grid (line 99) | pub fn cartesian_grid<S: Into<Shape>, const D2: usize>(
  function bitwise_and (line 107) | pub fn bitwise_and(self, other: Self) -> Self {
  function bitwise_or (line 112) | pub fn bitwise_or(self, other: Self) -> Self {
  function bitwise_xor (line 117) | pub fn bitwise_xor(self, other: Self) -> Self {
  function bitwise_not (line 122) | pub fn bitwise_not(self) -> Self {
  function bitwise_and_scalar (line 127) | pub fn bitwise_and_scalar(self, other: B::IntElem) -> Self {
  function bitwise_or_scalar (line 133) | pub fn bitwise_or_scalar(self, other: B::IntElem) -> Self {
  function bitwise_xor_scalar (line 139) | pub fn bitwise_xor_scalar(self, other: B::IntElem) -> Self {
  function bitwise_left_shift (line 145) | pub fn bitwise_left_shift(self, other: Self) -> Self {
  function bitwise_right_shift (line 150) | pub fn bitwise_right_shift(self, other: Self) -> Self {
  function bitwise_left_shift_scalar (line 155) | pub fn bitwise_left_shift_scalar(self, other: B::IntElem) -> Self {
  function bitwise_right_shift_scalar (line 161) | pub fn bitwise_right_shift_scalar(self, other: B::IntElem) -> Self {
  function cast (line 173) | pub fn cast<F: Into<IntDType>>(self, dtype: F) -> Tensor<B, D, Int> {

FILE: crates/burn-tensor/src/tensor/api/numeric.rs
  function add (line 43) | pub fn add(self, other: Self) -> Self {
  function add_scalar (line 71) | pub fn add_scalar<E: ElementConversion>(self, other: E) -> Self {
  function sub (line 100) | pub fn sub(self, other: Self) -> Self {
  function sub_scalar (line 128) | pub fn sub_scalar<E: ElementConversion>(self, other: E) -> Self {
  function div (line 157) | pub fn div(self, other: Self) -> Self {
  function div_scalar (line 185) | pub fn div_scalar<E: ElementConversion>(self, other: E) -> Self {
  function remainder (line 193) | pub fn remainder(self, other: Self) -> Self {
  function remainder_scalar (line 220) | pub fn remainder_scalar<E: ElementConversion>(self, other: E) -> Self {
  function mul (line 249) | pub fn mul(self, other: Self) -> Self {
  function mul_scalar (line 277) | pub fn mul_scalar<E: ElementConversion>(self, other: E) -> Self {
  function neg (line 301) | pub fn neg(self) -> Self {
  function sign (line 321) | pub fn sign(self) -> Self {
  function mean (line 341) | pub fn mean(self) -> Tensor<B, 1, K> {
  function sum (line 361) | pub fn sum(self) -> Tensor<B, 1, K> {
  function mean_dim (line 390) | pub fn mean_dim<I: AsIndex>(self, dim: I) -> Self {
  function mean_dims (line 422) | pub fn mean_dims<I: AsIndex>(self, dims: &[I]) -> Self {
  function sum_dim (line 451) | pub fn sum_dim<I: AsIndex>(self, dim: I) -> Self {
  function sum_dims (line 483) | pub fn sum_dims<I: AsIndex>(self, dims: &[I]) -> Self {
  function sum_dims_squeeze (line 517) | pub fn sum_dims_squeeze<const D2: usize, I: AsIndex>(self, dims: &[I]) -...
  function prod (line 542) | pub fn prod(self) -> Tensor<B, 1, K> {
  function prod_dim (line 576) | pub fn prod_dim<I: AsIndex>(self, dim: I) -> Self {
  function prod_dims (line 608) | pub fn prod_dims<I: AsIndex>(self, dims: &[I]) -> Self {
  function cumsum (line 635) | pub fn cumsum(self, dim: usize) -> Self {
  function cumprod (line 663) | pub fn cumprod(self, dim: usize) -> Self {
  function abs (line 689) | pub fn abs(self) -> Self {
  function triu (line 727) | pub fn triu(self, diagonal: i64) -> Self {
  function tril (line 772) | pub fn tril(self, diagonal: i64) -> Self {
  function powi (line 803) | pub fn powi(self, other: Self) -> Self {
  function powi_scalar (line 832) | pub fn powi_scalar<E: ElementConversion>(self, other: E) -> Self {
  function bool (line 859) | pub fn bool(self) -> Tensor<B, D, Bool> {
  function random (line 895) | pub fn random<S: Into<Shape>>(
  function matmul (line 912) | pub fn matmul(self, other: Self) -> Self {
  function dot (line 969) | pub fn dot(self, other: Self) -> Self {
  function eye (line 985) | pub fn eye(size: usize, device: &B::Device) -> Self {
  type Output (line 999) | type Output = Self;
  function add (line 1001) | fn add(self, rhs: Self) -> Self::Output {
  type Output (line 1012) | type Output = Self;
  function add (line 1014) | fn add(self, other: E) -> Self::Output {
  type Output (line 1043) | type Output = Self;
  function sub (line 1045) | fn sub(self, rhs: Self) -> Self::Output {
  type Output (line 1056) | type Output = Self;
  function sub (line 1058) | fn sub(self, other: E) -> Self::Output {
  type Output (line 1087) | type Output = Self;
  function div (line 1089) | fn div(self, rhs: Self) -> Self::Output {
  type Output (line 1100) | type Output = Self;
  function div (line 1102) | fn div(self, other: E) -> Self::Output {
  type Output (line 1130) | type Output = Self;
  function rem (line 1132) | fn rem(self, rhs: Self) -> Self::Output {
  type Output (line 1143) | type Output = Self;
  function rem (line 1145) | fn rem(self, other: E) -> Self::Output {
  type Output (line 1155) | type Output = Self;
  function mul (line 1157) | fn mul(self, rhs: Self) -> Self::Output {
  type Output (line 1168) | type Output = Self;
  function mul (line 1170) | fn mul(self, other: E) -> Self::Output {
  type Output (line 1200) | type Output = Self;
  function neg (line 1202) | fn neg(self) -> Self::Output {

FILE: crates/burn-tensor/src/tensor/api/options.rs
  type TensorCreationOptions (line 14) | pub struct TensorCreationOptions<B: Backend> {
  method default (line 24) | fn default() -> Self {
  function new (line 33) | pub fn new(device: Device<B>) -> Self {
  function with_dtype (line 41) | pub fn with_dtype(mut self, dtype: DType) -> Self {
  function with_device (line 48) | pub fn with_device(mut self, device: Device<B>) -> Self {
  function float (line 55) | pub fn float() -> Self {
  function int (line 60) | pub fn int() -> Self {
  function bool (line 65) | pub fn bool() -> Self {
  function dtype_or (line 72) | pub fn dtype_or(&self, dtype: DType) -> DType {
  function resolve_policy (line 77) | pub(crate) fn resolve_policy<K: BasicOps<B>>(&self) -> DType {
  function from (line 113) | fn from(device: &Device<B>) -> Self {
  function from (line 120) | fn from(args: (&Device<B>, DType)) -> Self {

FILE: crates/burn-tensor/src/tensor/api/orderable.rs
  function sort (line 44) | pub fn sort(self, dim: usize) -> Self {
  function sort_descending (line 78) | pub fn sort_descending(self, dim: usize) -> Self {
  function sort_with_indices (line 112) | pub fn sort_with_indices(self, dim: usize) -> (Self, Tensor<B, D, Int>) {
  function sort_descending_with_indices (line 144) | pub fn sort_descending_with_indices(self, dim: usize) -> (Self, Tensor<B...
  function argsort (line 172) | pub fn argsort(self, dim: usize) -> Tensor<B, D, Int> {
  function argsort_descending (line 202) | pub fn argsort_descending(self, dim: usize) -> Tensor<B, D, Int> {
  function topk (line 234) | pub fn topk(self, k: usize, dim: usize) -> Self {
  function topk_with_indices (line 268) | pub fn topk_with_indices(self, k: usize, dim: usize) -> (Self, Tensor<B,...
  function one_hot (line 293) | pub fn one_hot<const D2: usize>(self, num_classes: usize) -> Tensor<B, D...
  function one_hot_fill (line 327) | pub fn one_hot_fill<const D2: usize>(
  function greater (line 401) | pub fn greater(self, other: Self) -> Tensor<B, D, Bool> {
  function greater_equal (line 427) | pub fn greater_equal(self, other: Self) -> Tensor<B, D, Bool> {
  function lower (line 453) | pub fn lower(self, other: Self) -> Tensor<B, D, Bool> {
  function lower_equal (line 479) | pub fn lower_equal(self, other: Self) -> Tensor<B, D, Bool> {
  function greater_elem (line 504) | pub fn greater_elem<E: ElementConversion>(self, other: E) -> Tensor<B, D...
  function greater_equal_elem (line 529) | pub fn greater_equal_elem<E: ElementConversion>(self, other: E) -> Tenso...
  function lower_elem (line 554) | pub fn lower_elem<E: ElementConversion>(self, other: E) -> Tensor<B, D, ...
  function lower_equal_elem (line 579) | pub fn lower_equal_elem<E: ElementConversion>(self, other: E) -> Tensor<...
  function argmax (line 600) | pub fn argmax(self, dim: usize) -> Tensor<B, D, Int> {
  function max (line 620) | pub fn max(self) -> Tensor<B, 1, K> {
  function max_dim_with_indices (line 644) | pub fn max_dim_with_indices<I: AsIndex>(self, dim: I) -> (Self, Tensor<B...
  function max_abs (line 672) | pub fn max_abs(self) -> Tensor<B, 1, K> {
  function max_pair (line 702) | pub fn max_pair(self, other: Self) -> Self {
  function max_abs_dim (line 733) | pub fn max_abs_dim<I: AsIndex>(self, dim: I) -> Self {
  function max_abs_dims (line 766) | pub fn max_abs_dims<I: AsIndex>(self, dims: &[I]) -> Self {
  function argmin (line 787) | pub fn argmin(self, dim: usize) -> Tensor<B, D, Int> {
  function min (line 807) | pub fn min(self) -> Tensor<B, 1, K> {
  function min_dim (line 837) | pub fn min_dim<I: AsIndex>(self, dim: I) -> Self {
  function min_dims (line 869) | pub fn min_dims<I: AsIndex>(self, dims: &[I]) -> Self {
  function min_dim_with_indices (line 893) | pub fn min_dim_with_indices<I: AsIndex>(self, dim: I) -> (Self, Tensor<B...
  function min_pair (line 930) | pub fn min_pair(self, other: Self) -> Self {
  function clamp (line 966) | pub fn clamp<E: ElementConversion>(self, min: E, max: E) -> Self {
  function clamp_min (line 1002) | pub fn clamp_min<E: ElementConversion>(self, min: E) -> Self {
  function clamp_max (line 1034) | pub fn clamp_max<E: ElementConversion>(self, max: E) -> Self {
  function cummin (line 1062) | pub fn cummin(self, dim: usize) -> Self {
  function cummax (line 1090) | pub fn cummax(self, dim: usize) -> Self {
  function max_dim (line 1120) | pub fn max_dim<I: AsIndex>(self, dim: I) -> Self {
  function max_dims (line 1152) | pub fn max_dims<I: AsIndex>(self, dims: &[I]) -> Self {

FILE: crates/burn-tensor/src/tensor/api/pad.rs
  type IntoPadding (line 13) | pub trait IntoPadding<const D: usize> {
    method into_padding (line 15) | fn into_padding(self) -> [(usize, usize); D];
  function into_padding (line 19) | fn into_padding(self) -> [(usize, usize); D] {
  function into_padding (line 39) | fn into_padding(self) -> [(usize, usize); D] {
  function into_padding (line 49) | fn into_padding(self) -> [(usize, usize); D] {
  function into_padding (line 66) | fn into_padding(self) -> [(usize, usize); D] {
  function build_slice_ranges (line 83) | fn build_slice_ranges<const D: usize>(
  function pad (line 158) | pub fn pad(self, padding: impl IntoPadding<D>, mode: impl Into<PadMode>)...
  function pad_constant (line 169) | fn pad_constant<B, const D: usize, K, E>(
  function pad_reflect (line 206) | fn pad_reflect<B, const D: usize, K>(
  function pad_reflect_dim (line 242) | fn pad_reflect_dim<B, const D: usize, K>(
  function pad_edge (line 290) | fn pad_edge<B, const D: usize, K>(
  function pad_edge_dim (line 323) | fn pad_edge_dim<B, const D: usize, K>(

FILE: crates/burn-tensor/src/tensor/api/take.rs
  function take (line 43) | pub fn take<const DI: usize, const DO: usize>(

FILE: crates/burn-tensor/src/tensor/api/transaction.rs
  type Transaction (line 24) | pub struct Transaction<B: Backend> {
  function register (line 30) | pub fn register<const D: usize, K: BasicOps<B>>(mut self, tensor: Tensor...
  function execute (line 37) | pub fn execute(self) -> Vec<TensorData> {
  function try_execute (line 48) | pub fn try_execute(self) -> Result<Vec<TensorData>, ExecutionError> {
  function execute_async (line 54) | pub async fn execute_async(self) -> Result<Vec<TensorData>, ExecutionErr...

FILE: crates/burn-tensor/src/tensor/api/trunc.rs
  function trunc (line 37) | pub fn trunc(self) -> Self {

FILE: crates/burn-tensor/src/tensor/grid/affine_grid.rs
  function affine_grid_2d (line 21) | pub fn affine_grid_2d<B: Backend>(transform: Tensor<B, 3>, dims: [usize;...

FILE: crates/burn-tensor/src/tensor/grid/meshgrid.rs
  function meshgrid (line 31) | pub fn meshgrid<B: Backend, const N: usize, K, O>(
  function meshgrid_stack (line 88) | pub fn meshgrid_stack<B: Backend, const D: usize, const D2: usize, K>(

FILE: crates/burn-tensor/src/tensor/grid/mod.rs
  type GridIndexing (line 10) | pub enum GridIndexing {
  type GridSparsity (line 23) | pub enum GridSparsity {
  type GridOptions (line 34) | pub struct GridOptions {
    method from (line 43) | fn from(value: GridIndexing) -> Self {
    method from (line 51) | fn from(value: GridSparsity) -> Self {
  type IndexPos (line 61) | pub enum IndexPos {

FILE: crates/burn-tensor/src/tensor/linalg/cosine_similarity.rs
  constant DEFAULT_EPSILON (line 8) | pub const DEFAULT_EPSILON: f64 = 1e-8;
  function cosine_similarity (line 25) | pub fn cosine_similarity<B: Backend, const D: usize>(

FILE: crates/burn-tensor/src/tensor/linalg/diag.rs
  function diag (line 20) | pub fn diag<B: Backend, const D: usize, const DO: usize, K>(

FILE: crates/burn-tensor/src/tensor/linalg/lu_decomposition.rs
  function lu_decomposition (line 28) | pub fn lu_decomposition<B: Backend>(tensor: Tensor<B, 2>) -> (Tensor<B, ...

FILE: crates/burn-tensor/src/tensor/linalg/matvec.rs
  function matvec (line 17) | pub fn matvec<B: Backend, const DM: usize, const DV: usize, K>(

FILE: crates/burn-tensor/src/tensor/linalg/mod.rs
  function swap_slices (line 28) | fn swap_slices<B: Backend, const D: usize, K, S>(

FILE: crates/burn-tensor/src/tensor/linalg/outer.rs
  function outer (line 20) | pub fn outer<B: Backend, const D: usize, const R: usize, K>(
  function outer_dim (line 52) | pub fn outer_dim<B: Backend, const D: usize, const R: usize, Dim: AsInde...

FILE: crates/burn-tensor/src/tensor/linalg/trace.rs
  function trace (line 20) | pub fn trace<B: Backend, const D: usize, const DO: usize>(tensor: Tensor...

FILE: crates/burn-tensor/src/tensor/linalg/vector_norm.rs
  type Norm (line 10) | pub enum Norm {
    method to_exponent (line 32) | pub fn to_exponent(self) -> f64 {
    method from (line 46) | fn from(value: u32) -> Self {
    method from (line 59) | fn from(value: i32) -> Self {
    method from (line 73) | fn from(value: f32) -> Self {
    method from (line 87) | fn from(value: f64) -> Self {
  function vector_norm (line 117) | pub fn vector_norm<B: Backend, const D: usize>(
  function lp_norm (line 144) | pub fn lp_norm<B: Backend, const D: usize>(x: Tensor<B, D>, p: f64, dim:...
  function vector_normalize (line 170) | pub fn vector_normalize<B: Backend, const D: usize, E: ElementConversion>(
  function l0_norm (line 190) | pub fn l0_norm<B: Backend, const D: usize, K>(x: Tensor<B, D, K>, dim: u...
  function l1_norm (line 211) | pub fn l1_norm<B: Backend, const D: usize, K>(x: Tensor<B, D, K>, dim: u...
  function l2_norm (line 228) | pub fn l2_norm<B: Backend, const D: usize>(x: Tensor<B, D>, dim: usize) ...
  function is_even_integer (line 232) | fn is_even_integer(x: f64) -> bool {
  function lp_signed_norm (line 239) | fn lp_signed_norm<B: Backend, const D: usize>(x: Tensor<B, D>, p: u32, d...
  function lp_norm_base (line 249) | fn lp_norm_base<B: Backend, const D: usize>(x: Tensor<B, D>, p: f64, dim...
  function max_abs_norm (line 263) | pub fn max_abs_norm<B: Backend, const D: usize, K>(
  function min_abs_norm (line 283) | pub fn min_abs_norm<B: Backend, const D: usize, K>(

FILE: crates/burn-tensor/src/tensor/loss/mod.rs
  function cross_entropy_with_logits (line 14) | pub fn cross_entropy_with_logits<B: Backend, const D: usize>(

FILE: crates/burn-tensor/src/tensor/module.rs
  function embedding (line 15) | pub fn embedding<B>(weights: Tensor<B, 2>, indices: Tensor<B, 2, Int>) -...
  function conv1d (line 30) | pub fn conv1d<B>(
  function conv2d (line 79) | pub fn conv2d<B>(
  function conv3d (line 129) | pub fn conv3d<B>(
  function deform_conv2d (line 159) | pub fn deform_conv2d<B>(
  function conv_transpose1d (line 187) | pub fn conv_transpose1d<B>(
  function conv_transpose2d (line 210) | pub fn conv_transpose2d<B>(
  function conv_transpose3d (line 233) | pub fn conv_transpose3d<B>(
  function unfold4d (line 256) | pub fn unfold4d<B>(x: Tensor<B, 4>, kernel_size: [usize; 2], options: Un...
  function max_pool1d (line 268) | pub fn max_pool1d<B>(
  function max_pool2d (line 290) | pub fn max_pool2d<B>(
  function avg_pool2d (line 312) | pub fn avg_pool2d<B>(
  function avg_pool1d (line 334) | pub fn avg_pool1d<B>(
  function max_pool1d_with_indices (line 356) | pub fn max_pool1d_with_indices<B>(
  function max_pool2d_with_indices (line 383) | pub fn max_pool2d_with_indices<B>(
  function adaptive_avg_pool2d (line 410) | pub fn adaptive_avg_pool2d<B>(x: Tensor<B, 4>, output_size: [usize; 2]) ...
  function adaptive_avg_pool1d (line 421) | pub fn adaptive_avg_pool1d<B>(x: Tensor<B, 3>, output_size: usize) -> Te...
  function interpolate (line 432) | pub fn interpolate<B>(
  function linear (line 472) | pub fn linear<B: Backend, const D: usize>(
  function attention (line 518) | pub fn attention<B: Backend>(
  function attention_fallback (line 537) | pub fn attention_fallback<B: Backend>(

FILE: crates/burn-tensor/src/tensor/quantization.rs
  type QuantizationParameters (line 8) | pub type QuantizationParameters<B> = QParams<Tensor<B, 1>>;
  type CalibrationRange (line 12) | pub struct CalibrationRange<B: Backend> {
  function compute_range (line 20) | pub fn compute_range<B: Backend, const D: usize>(
  function compute_q_params (line 39) | pub fn compute_q_params<B: Backend>(

FILE: crates/burn-tensor/src/tensor/report.rs
  function check_closeness (line 74) | pub fn check_closeness<B: Backend, const D: usize>(output: &Tensor<B, D>...

FILE: crates/burn-tensor/src/tensor/stats/mod.rs
  function var (line 4) | pub fn var<B: Backend, const D: usize>(tensor: Tensor<B, D>, dim: usize)...
  function var_with_mean (line 9) | pub fn var_with_mean<B: Backend, const D: usize>(
  function var_bias (line 18) | pub fn var_bias<B: Backend, const D: usize>(tensor: Tensor<B, D>, dim: u...
  function var_with_mean_bias (line 23) | pub fn var_with_mean_bias<B: Backend, const D: usize>(
  function var_with_mean_n (line 32) | pub fn var_with_mean_n<B: Backend, const D: usize>(
  function median (line 41) | pub fn median<B: Backend, const D: usize>(tensor: Tensor<B, D>, dim: usi...
  function median_with_indices (line 56) | pub fn median_with_indices<B: Backend, const D: usize>(

FILE: crates/burn-train/src/checkpoint/async_checkpoint.rs
  type Message (line 6) | enum Message<R, B: Backend> {
  type CheckpointerThread (line 19) | struct CheckpointerThread<C, R, B: Backend> {
  function run (line 30) | fn run(self) {
  type AsyncCheckpointer (line 72) | pub struct AsyncCheckpointer<Record, B: Backend> {
  function new (line 92) | pub fn new<C>(checkpointer: C) -> Self
  function with_interrupter (line 109) | pub fn with_interrupter(mut self, interrupter: Interrupter) -> Self {
  function save (line 120) | fn save(&self, epoch: usize, record: R) -> Result<(), CheckpointerError> {
  function restore (line 128) | fn restore(&self, epoch: usize, device: &B::Device) -> Result<R, Checkpo...
  function delete (line 146) | fn delete(&self, epoch: usize) -> Result<(), CheckpointerError> {
  method drop (line 159) | fn drop(&mut self) {

FILE: crates/burn-train/src/checkpoint/base.rs
  type CheckpointerError (line 9) | pub enum CheckpointerError {
  type Checkpointer (line 24) | pub trait Checkpointer<R, B>: Send + Sync
    method save (line 35) | fn save(&self, epoch: usize, record: R) -> Result<(), CheckpointerError>;
    method delete (line 38) | fn delete(&self, epoch: usize) -> Result<(), CheckpointerError>;
    method restore (line 50) | fn restore(&self, epoch: usize, device: &B::Device) -> Result<R, Check...

FILE: crates/burn-train/src/checkpoint/file.rs
  type FileCheckpointer (line 10) | pub struct FileCheckpointer<FR> {
  function new (line 24) | pub fn new(recorder: FR, directory: impl AsRef<Path>, name: &str) -> Self {
  function path_for_epoch (line 35) | fn path_for_epoch(&self, epoch: usize) -> PathBuf {
  function save (line 46) | fn save(&self, epoch: usize, record: R) -> Result<(), CheckpointerError> {
  function restore (line 57) | fn restore(&self, epoch: usize, device: &B::Device) -> Result<R, Checkpo...
  function delete (line 72) | fn delete(&self, epoch: usize) -> Result<(), CheckpointerError> {

FILE: crates/burn-train/src/checkpoint/strategy/base.rs
  type CheckpointingAction (line 7) | pub enum CheckpointingAction {
  type CheckpointingStrategy (line 15) | pub trait CheckpointingStrategy: Send {
    method checkpointing (line 17) | fn checkpointing(
    method checkpointing (line 27) | fn checkpointing(

FILE: crates/burn-train/src/checkpoint/strategy/composed.rs
  type ComposedCheckpointingStrategy (line 8) | pub struct ComposedCheckpointingStrategy {
    method new (line 37) | fn new(strategies: Vec<Box<dyn CheckpointingStrategy>>) -> Self {
    method builder (line 45) | pub fn builder() -> ComposedCheckpointingStrategyBuilder {
  type ComposedCheckpointingStrategyBuilder (line 15) | pub struct ComposedCheckpointingStrategyBuilder {
    method add (line 22) | pub fn add<S>(mut self, strategy: S) -> Self
    method build (line 31) | pub fn build(self) -> ComposedCheckpointingStrategy {
  method checkpointing (line 51) | fn checkpointing(
  function should_delete_when_both_deletes (line 124) | fn should_delete_when_both_deletes() {

FILE: crates/burn-train/src/checkpoint/strategy/lastn.rs
  type KeepLastNCheckpoints (line 9) | pub struct KeepLastNCheckpoints {
  method checkpointing (line 14) | fn checkpointing(
  function should_always_delete_lastn_epoch_if_higher_than_one (line 37) | fn should_always_delete_lastn_epoch_if_higher_than_one() {

FILE: crates/burn-train/src/checkpoint/strategy/metric.rs
  type MetricCheckpointingStrategy (line 11) | pub struct MetricCheckpointingStrategy {
    method new (line 21) | pub fn new<M>(metric: &M, aggregate: Aggregate, direction: Direction, ...
  method checkpointing (line 36) | fn checkpointing(
  function always_keep_the_best_epoch (line 84) | fn always_keep_the_best_epoch() {

FILE: crates/burn-train/src/components.rs
  type LearningComponentsTypes (line 7) | pub trait LearningComponentsTypes {
    type Backend (line 39) | type Backend = B;
    type LrScheduler (line 40) | type LrScheduler = LR;
    type TrainingModel (line 41) | type TrainingModel = M;
    type InferenceModel (line 42) | type InferenceModel = M::InnerModule;
    type Optimizer (line 43) | type Optimizer = O;
  type LearningComponentsMarker (line 24) | pub struct LearningComponentsMarker<B, LR, M, O> {
  type TrainingBackend (line 47) | pub type TrainingBackend<LC> = <LC as LearningComponentsTypes>::Backend;
  type InferenceBackend (line 49) | pub(crate) type InferenceBackend<LC> =
  type TrainingModel (line 52) | pub type TrainingModel<LC> = <LC as LearningComponentsTypes>::TrainingMo...
  type InferenceModel (line 54) | pub(crate) type InferenceModel<LC> = <LC as LearningComponentsTypes>::In...
  type TrainingModelInput (line 56) | pub(crate) type TrainingModelInput<LC> =
  type InferenceModelInput (line 59) | pub(crate) type InferenceModelInput<LC> =
  type TrainingModelOutput (line 62) | pub(crate) type TrainingModelOutput<LC> =
  type InferenceModelOutput (line 65) | pub(crate) type InferenceModelOutput<LC> =

FILE: crates/burn-train/src/evaluator/base.rs
  type TestBackend (line 11) | pub(crate) type TestBackend<EC> = <EC as EvaluatorComponentTypes>::Backend;
  type TestInput (line 12) | pub(crate) type TestInput<EC> = <<EC as EvaluatorComponentTypes>::Model ...
  type TestOutput (line 13) | pub(crate) type TestOutput<EC> = <<EC as EvaluatorComponentTypes>::Model...
  type TestLoader (line 15) | pub(crate) type TestLoader<EC> = Arc<dyn DataLoader<TestBackend<EC>, Tes...
  type Evaluator (line 18) | pub struct Evaluator<EC: EvaluatorComponentTypes> {
  function eval (line 31) | pub fn eval<S: core::fmt::Display>(

FILE: crates/burn-train/src/evaluator/builder.rs
  type EvaluatorBuilder (line 24) | pub struct EvaluatorBuilder<EC: EvaluatorComponentTypes> {
  function new (line 45) | pub fn new(directory: impl AsRef<Path>) -> Self {
  function metrics (line 64) | pub fn metrics<Me: EvalMetricRegistration<EC>>(self, metrics: Me) -> Self {
  function metrics_text (line 69) | pub fn metrics_text<Me: EvalTextMetricRegistration<EC>>(self, metrics: M...
  function with_application_logger (line 76) | pub fn with_application_logger(
  function metric_numeric (line 85) | pub fn metric_numeric<Me>(mut self, metric: Me) -> Self
  function metric (line 96) | pub fn metric<Me>(mut self, metric: Me) -> Self
  function renderer (line 111) | pub fn renderer(mut self, renderer: Box<dyn MetricsRenderer + 'static>) ...
  function summary (line 119) | pub fn summary(mut self) -> Self {
  function build (line 126) | pub fn build(mut self, model: EC::Model) -> Evaluator<EC> {
  type EvalMetricRegistration (line 160) | pub trait EvalMetricRegistration<EC: EvaluatorComponentTypes>: Sized {
    method register (line 162) | fn register(self, builder: EvaluatorBuilder<EC>) -> EvaluatorBuilder<EC>;
  type EvalTextMetricRegistration (line 166) | pub trait EvalTextMetricRegistration<EC: EvaluatorComponentTypes>: Sized {
    method register (line 168) | fn register(self, builder: EvaluatorBuilder<EC>) -> EvaluatorBuilder<EC>;

FILE: crates/burn-train/src/evaluator/components.rs
  type EvaluatorComponentTypes (line 6) | pub trait EvaluatorComponentTypes {
    type Backend (line 23) | type Backend = B;
    type Model (line 24) | type Model = M;
  type EvaluatorComponentTypesMarker (line 14) | pub struct EvaluatorComponentTypesMarker<B, M> {

FILE: crates/burn-train/src/learner/application_logger.rs
  type ApplicationLoggerInstaller (line 8) | pub trait ApplicationLoggerInstaller {
    method install (line 10) | fn install(&self) -> Result<(), String>;
    method install (line 28) | fn install(&self) -> Result<(), String> {
  type FileApplicationLoggerInstaller (line 14) | pub struct FileApplicationLoggerInstaller {
    method new (line 20) | pub fn new(path: impl AsRef<Path>) -> Self {

FILE: crates/burn-train/src/learner/base.rs
  type LearnerModelRecord (line 21) | pub type LearnerModelRecord<LC> =
  type LearnerOptimizerRecord (line 24) | pub type LearnerOptimizerRecord<LC> = <<LC as LearningComponentsTypes>::...
  type LearnerSchedulerRecord (line 29) | pub type LearnerSchedulerRecord<LC> =
  type Learner (line 33) | pub struct Learner<LC: LearningComponentsTypes> {
  method clone (line 41) | fn clone(&self) -> Self {
  function new (line 60) | pub fn new(model: M, optim: O, lr_scheduler: LR) -> Self {
  function fork (line 72) | pub fn fork(&mut self, device: &<TrainingBackend<LC> as Backend>::Device) {
  function model (line 77) | pub fn model(&self) -> LC::TrainingModel {
  function lr_current (line 82) | pub fn lr_current(&self) -> f64 {
  function lr_step (line 87) | pub fn lr_step(&mut self) {
  function train_step (line 100) | pub fn train_step(&self, item: TrainingModelInput<LC>) -> TrainOutput<Tr...
  function optimizer_step (line 111) | pub fn optimizer_step(&mut self, grads: GradientsParams) {
  function optimizer_step_multi (line 122) | pub fn optimizer_step_multi(&mut self, grads: MultiGradientsParams) {
  function load_model (line 127) | pub fn load_model(&mut self, record: LearnerModelRecord<LC>) {
  function load_optim (line 132) | pub fn load_optim(&mut self, record: LearnerOptimizerRecord<LC>) {
  function load_scheduler (line 137) | pub fn load_scheduler(&mut self, record: LearnerSchedulerRecord<LC>) {
  type LearningCheckpointer (line 144) | pub struct LearningCheckpointer<LC: LearningComponentsTypes> {
  function checkpoint (line 153) | pub fn checkpoint(&mut self, learner: &Learner<LC>, epoch: usize, store:...
  function load_checkpoint (line 185) | pub fn load_checkpoint(
  type EarlyStoppingStrategyRef (line 214) | pub(crate) type EarlyStoppingStrategyRef = Box<dyn CloneEarlyStoppingStr...
  type Interrupter (line 218) | pub struct Interrupter {
    method new (line 225) | pub fn new() -> Self {
    method stop (line 232) | pub fn stop(&self, reason: Option<&str>) {
    method reset (line 241) | pub fn reset(&self) {
    method should_stop (line 246) | pub fn should_stop(&self) -> bool {
    method get_message (line 251) | pub fn get_message(&self) -> Option<String> {

FILE: crates/burn-train/src/learner/classification.rs
  type ClassificationOutput (line 21) | pub struct ClassificationOutput<B: Backend> {
  type ItemSync (line 33) | type ItemSync = ClassificationOutput<NdArray>;
  method sync (line 35) | fn sync(self) -> Self::ItemSync {
  function adapt (line 55) | fn adapt(&self) -> AccuracyInput<B> {
  function adapt (line 61) | fn adapt(&self) -> AurocInput<B> {
  function adapt (line 67) | fn adapt(&self) -> LossInput<B> {
  function adapt (line 73) | fn adapt(&self) -> TopKAccuracyInput<B> {
  function adapt (line 79) | fn adapt(&self) -> PerplexityInput<B> {
  function adapt (line 85) | fn adapt(&self) -> ConfusionStatsInput<B> {
  type MultiLabelClassificationOutput (line 110) | pub struct MultiLabelClassificationOutput<B: Backend> {
  type ItemSync (line 122) | type ItemSync = MultiLabelClassificationOutput<NdArray>;
  method sync (line 124) | fn sync(self) -> Self::ItemSync {
  function adapt (line 144) | fn adapt(&self) -> HammingScoreInput<B> {
  function adapt (line 150) | fn adapt(&self) -> LossInput<B> {
  function adapt (line 156) | fn adapt(&self) -> ConfusionStatsInput<B> {

FILE: crates/burn-train/src/learner/early_stopping.rs
  type StoppingCondition (line 8) | pub enum StoppingCondition {
  type EarlyStoppingStrategy (line 17) | pub trait EarlyStoppingStrategy: Send {
    method should_stop (line 19) | fn should_stop(&mut self, epoch: usize, store: &EventStoreClient) -> b...
    method should_stop (line 61) | fn should_stop(&mut self, epoch: usize, store: &EventStoreClient) -> b...
  type CloneEarlyStoppingStrategy (line 23) | pub trait CloneEarlyStoppingStrategy: EarlyStoppingStrategy + Send {
    method clone_box (line 25) | fn clone_box(&self) -> Box<dyn CloneEarlyStoppingStrategy>;
    method clone_box (line 34) | fn clone_box(&self) -> Box<dyn CloneEarlyStoppingStrategy> {
  method clone (line 41) | fn clone(&self) -> Box<dyn CloneEarlyStoppingStrategy> {
  type MetricEarlyStoppingStrategy (line 49) | pub struct MetricEarlyStoppingStrategy {
    method new (line 124) | pub fn new<Me: Metric>(
    method warmup_epochs (line 151) | pub fn warmup_epochs(&self) -> Option<usize> {
    method with_warmup_epochs (line 161) | pub fn with_warmup_epochs(self, warmup: Option<usize>) -> Self {
  function never_early_stop_while_it_is_improving (line 189) | fn never_early_stop_while_it_is_improving() {
  function early_stop_when_no_improvement_since_two_epochs (line 203) | fn early_stop_when_no_improvement_since_two_epochs() {
  function early_stopping_with_warmup (line 225) | fn early_stopping_with_warmup() {
  function early_stop_when_stays_equal (line 243) | fn early_stop_when_stays_equal() {
  function test_early_stopping (line 263) | fn test_early_stopping(warmup: Option<usize>, n_epochs: usize, data: &[(...

FILE: crates/burn-train/src/learner/regression.rs
  type RegressionOutput (line 9) | pub struct RegressionOutput<B: Backend> {
  function adapt (line 21) | fn adapt(&self) -> LossInput<B> {
  type ItemSync (line 27) | type ItemSync = RegressionOutput<NdArray>;
  method sync (line 29) | fn sync(self) -> Self::ItemSync {

FILE: crates/burn-train/src/learner/rl/checkpointer.rs
  type RLCheckpointer (line 14) | pub struct RLCheckpointer<RLC: RLComponentsTypes> {
  function checkpoint (line 22) | pub fn checkpoint(
  function load_checkpoint (line 54) | pub fn load_checkpoint(

FILE: crates/burn-train/src/learner/rl/components.rs
  type RLComponentsTypes (line 9) | pub trait RLComponentsTypes {
    type Backend (line 85) | type Backend = B;
    type Env (line 86) | type Env = E;
    type EnvInit (line 87) | type EnvInit = EI;
    type LearningAgent (line 88) | type LearningAgent = A;
    type Policy (line 89) | type Policy = A::InnerPolicy;
    type PolicyObs (line 90) | type PolicyObs = <A::InnerPolicy as Policy<B>>::Observation;
    type PolicyAD (line 91) | type PolicyAD = <A::InnerPolicy as Policy<B>>::ActionDistribution;
    type PolicyAction (line 92) | type PolicyAction = <A::InnerPolicy as Policy<B>>::Action;
    type ActionContext (line 93) | type ActionContext = <A::InnerPolicy as Policy<B>>::ActionContext;
    type PolicyState (line 94) | type PolicyState = <A::InnerPolicy as Policy<B>>::PolicyState;
    type TrainingOutput (line 95) | type TrainingOutput = A::TrainContext;
    type State (line 96) | type State = E::State;
    type Action (line 97) | type Action = E::Action;
  type RLComponentsMarker (line 58) | pub struct RLComponentsMarker<B, E, EI, A> {
  type RlPolicy (line 100) | pub(crate) type RlPolicy<RLC> = <<RLC as RLComponentsTypes>::LearningAge...
  type RLEventProcessorType (line 104) | pub type RLEventProcessorType<RLC> = AsyncProcessorTraining<
  type RLPolicyRecord (line 109) | pub type RLPolicyRecord<RLC> = <<<RLC as RLComponentsTypes>::Policy as P...
  type RLAgentRecord (line 113) | pub type RLAgentRecord<RLC> = <<RLC as RLComponentsTypes>::LearningAgent...

FILE: crates/burn-train/src/learner/rl/env_runner/async_runner.rs
  type RequestMessage (line 19) | enum RequestMessage {
  type AsyncAgentEnvLoopConfig (line 25) | pub struct AsyncAgentEnvLoopConfig {
  type AgentEnvAsyncLoop (line 35) | pub struct AgentEnvAsyncLoop<BT: Backend, RLC: RLComponentsTypes> {
  function new (line 57) | pub fn new(
  function run_steps (line 170) | fn run_steps(
  function run_episodes (line 215) | fn run_episodes(
  function update_policy (line 283) | fn update_policy(&mut self, update: RLC::PolicyState) {
  function policy (line 287) | fn policy(&self) -> RLC::PolicyState {
  type MultiAgentEnvLoop (line 293) | pub struct MultiAgentEnvLoop<BT: Backend, RLC: RLComponentsTypes> {
  function new (line 304) | pub fn new(
  function run_steps (line 358) | fn run_steps(
  function update_policy (line 404) | fn update_policy(&mut self, update: RLC::PolicyState) {
  function run_episodes (line 408) | fn run_episodes(
  function policy (line 492) | fn policy(&self) -> RLC::PolicyState {
  function setup_async_loop (line 512) | fn setup_async_loop(
  function setup_multi_loop (line 534) | fn setup_multi_loop(
  function test_policy_async_loop (line 554) | fn test_policy_async_loop() {
  function test_update_policy_async_loop (line 561) | fn test_update_policy_async_loop() {
  function run_steps_returns_requested_number_async_loop (line 569) | fn run_steps_returns_requested_number_async_loop() {
  function run_episodes_returns_requested_number_async_loop (line 585) | fn run_episodes_returns_requested_number_async_loop() {
  function test_policy_multi_loop (line 605) | fn test_policy_multi_loop() {
  function test_update_policy_multi_loop (line 612) | fn test_update_policy_multi_loop() {
  function run_steps_returns_requested_number_multi_loop (line 620) | fn run_steps_returns_requested_number_multi_loop() {
  function run_episodes_returns_requested_number_multi_loop (line 659) | fn run_episodes_returns_requested_number_multi_loop() {

FILE: crates/burn-train/src/learner/rl/env_runner/base.rs
  type Trajectory (line 18) | pub struct Trajectory<B: Backend, S, A, C> {
  type TimeStep (line 25) | pub struct TimeStep<B: Backend, S, A, C> {
  type RLTimeStep (line 40) | pub(crate) type RLTimeStep<B, RLC> = TimeStep<
  type RLTrajectory (line 47) | pub(crate) type RLTrajectory<B, RLC> = Trajectory<
  type AgentEnvLoop (line 55) | pub trait AgentEnvLoop<BT: Backend, RLC: RLComponentsTypes> {
    method run_steps (line 69) | fn run_steps(
    method run_episodes (line 88) | fn run_episodes(
    method update_policy (line 96) | fn update_policy(&mut self, update: RLC::PolicyState);
    method policy (line 98) | fn policy(&self) -> RLC::PolicyState;
  type AgentEnvBaseLoop (line 102) | pub struct AgentEnvBaseLoop<B: Backend, RLC: RLComponentsTypes> {
  function new (line 115) | pub fn new(
  function run_steps (line 142) | fn run_steps(
  function update_policy (line 213) | fn update_policy(&mut self, update: RLC::PolicyState) {
  function run_episodes (line 217) | fn run_episodes(
  function policy (line 267) | fn policy(&self) -> RLC::PolicyState {
  function setup (line 283) | fn setup(
  function test_policy_returns_agent_state (line 294) | fn test_policy_returns_agent_state() {
  function test_update_policy (line 301) | fn test_update_policy() {
  function run_steps_returns_requested_number (line 309) | fn run_steps_returns_requested_number() {
  function run_episodes_returns_requested_number (line 325) | fn run_episodes_returns_requested_number() {

FILE: crates/burn-train/src/learner/rl/env_runner/mod.rs
  type MockPolicy (line 26) | pub(crate) struct MockPolicy(pub usize);
    type Observation (line 29) | type Observation = MockObservation;
    type ActionDistribution (line 30) | type ActionDistribution = MockActionDistribution;
    type Action (line 31) | type Action = MockPolicyAction;
    type ActionContext (line 32) | type ActionContext = MockActionContext;
    type PolicyState (line 33) | type PolicyState = MockPolicyState;
    method forward (line 35) | fn forward(&mut self, obs: Self::Observation) -> Self::ActionDistribut...
    method action (line 43) | fn action(
    method update (line 63) | fn update(&mut self, update: Self::PolicyState) {
    method state (line 67) | fn state(&self) -> Self::PolicyState {
    method load_record (line 71) | fn load_record(
  type MockObservation (line 81) | pub(crate) struct MockObservation(pub Vec<f32>);
    method from (line 159) | fn from(_value: MockState) -> Self {
  type MockPolicyAction (line 85) | pub(crate) struct MockPolicyAction(pub Vec<i32>);
    method from (line 171) | fn from(value: MockAction) -> Self {
  type MockActionDistribution (line 89) | pub(crate) struct MockActionDistribution(Vec<f32>);
  type MockActionContext (line 92) | pub(crate) struct MockActionContext;
  type MockPolicyState (line 96) | pub(crate) struct MockPolicyState(pub usize);
    type Record (line 99) | type Record = ();
    method into_record (line 101) | fn into_record(self) -> Self::Record {}
    method load_record (line 103) | fn load_record(&self, _record: Self::Record) -> Self {
  method batch (line 109) | fn batch(items: Vec<Self>) -> Self {
  method unbatch (line 113) | fn unbatch(self) -> Vec<Self> {
  method batch (line 119) | fn batch(items: Vec<Self>) -> Self {
  method unbatch (line 123) | fn unbatch(self) -> Vec<Self> {
  method batch (line 133) | fn batch(items: Vec<Self>) -> Self {
  method unbatch (line 137) | fn unbatch(self) -> Vec<Self> {
  type MockEnv (line 148) | pub(crate) struct MockEnv {
    method new (line 185) | fn new() -> Self {
  type MockState (line 153) | pub(crate) struct MockState;
  type MockAction (line 156) | pub(crate) struct MockAction(pub i32);
    method from (line 165) | fn from(value: MockPolicyAction) -> Self {
  type ItemSync (line 177) | type ItemSync = MockActionContext;
  method sync (line 179) | fn sync(self) -> Self::ItemSync {
  type State (line 191) | type State = MockState;
  type Action (line 192) | type Action = MockAction;
  constant MAX_STEPS (line 193) | const MAX_STEPS: usize = 5;
  method reset (line 195) | fn reset(&mut self) {
  method step (line 199) | fn step(&mut self, _action: Self::Action) -> StepResult<Self::State> {
  method state (line 211) | fn state(&self) -> Self::State {
  type MockEnvInit (line 218) | pub(crate) struct MockEnvInit;
    method init (line 221) | fn init(&self) -> MockEnv {
  type MockRLComponents (line 227) | pub(crate) struct MockRLComponents;
  type Backend (line 230) | type Backend = TestAutodiffBackend;
  type Env (line 231) | type Env = MockEnv;
  type EnvInit (line 232) | type EnvInit = MockEnvInit;
  type State (line 233) | type State = MockState;
  type Action (line 234) | type Action = MockAction;
  type Policy (line 235) | type Policy = MockPolicy;
  type PolicyObs (line 236) | type PolicyObs = MockObservation;
  type PolicyAD (line 237) | type PolicyAD = MockActionDistribution;
  type PolicyAction (line 238) | type PolicyAction = MockPolicyAction;
  type ActionContext (line 239) | type ActionContext = MockActionContext;
  type PolicyState (line 240) | type PolicyState = MockPolicyState;
  type LearningAgent (line 241) | type LearningAgent = MockLearningAgent;
  type TrainingOutput (line 242) | type TrainingOutput = ();
  type MockLearningAgent (line 247) | pub(crate) struct MockLearningAgent;
    type InnerPolicy (line 250) | type InnerPolicy = MockPolicy;
    type TrainContext (line 251) | type TrainContext = ();
    type Record (line 252) | type Record = ();
    method train (line 254) | fn train(
    method policy (line 264) | fn policy(&self) -> Self::InnerPolicy {
    method update_policy (line 268) | fn update_policy(&mut self, _update: Self::InnerPolicy) {
    method record (line 272) | fn record(&self) -> Self::Record {
    method load_record (line 276) | fn load_record(self, _record: Self::Record) -> Self {
  type MockProcessor (line 282) | pub(crate) struct MockProcessor;
    method process_train (line 290) | fn process_train(&mut self, _event: RLEvent<(), MockActionContext>) {
    method process_valid (line 294) | fn process_valid(&mut self, _event: AgentEvaluationEvent<MockActionCon...
    method renderer (line 298) | fn renderer(self) -> Box<dyn crate::renderer::MetricsRenderer> {

FILE: crates/burn-train/src/learner/rl/off_policy.rs
  type OffPolicyConfig (line 15) | pub struct OffPolicyConfig {
  type OffPolicyStrategy (line 47) | pub struct OffPolicyStrategy<RLC: RLComponentsTypes> {
  function new (line 53) | pub fn new(config: OffPolicyConfig) -> Self {
  function train_loop (line 67) | fn train_loop(

FILE: crates/burn-train/src/learner/rl/output.rs
  type EpisodeSummary (line 7) | pub struct EpisodeSummary {
    method adapt (line 23) | fn adapt(&self) -> EpisodeLengthInput {
    method adapt (line 29) | fn adapt(&self) -> CumulativeRewardInput {
  type ItemSync (line 15) | type ItemSync = EpisodeSummary;
  method sync (line 17) | fn sync(self) -> Self::ItemSync {

FILE: crates/burn-train/src/learner/rl/paradigm.rs
  type RLTraining (line 25) | pub struct RLTraining<RLC: RLComponentsTypes> {
  function new (line 75) | pub fn new(directory: impl AsRef<Path>, env_initializer: EI) -> Self {
  function with_learning_strategy (line 116) | pub fn with_learning_strategy(mut self, learning_strategy: RLStrategies<...
  function with_metric_logger (line 126) | pub fn with_metric_logger<ML>(mut self, logger: ML) -> Self
  function with_checkpointing_strategy (line 135) | pub fn with_checkpointing_strategy<CS: CheckpointingStrategy + 'static>(
  function renderer (line 148) | pub fn renderer<MR>(mut self, renderer: MR) -> Self
  function metrics_train (line 157) | pub fn metrics_train<Me: TrainMetricRegistration<RLC>>(self, metrics: Me...
  function text_metrics_train (line 162) | pub fn text_metrics_train<Me: TrainTextMetricRegistration<RLC>>(self, me...
  function metrics_agent (line 167) | pub fn metrics_agent<Me: AgentMetricRegistration<RLC>>(self, metrics: Me...
  function text_metrics_agent (line 172) | pub fn text_metrics_agent<Me: AgentTextMetricRegistration<RLC>>(self, me...
  function metrics_episode (line 177) | pub fn metrics_episode<Me: EpisodeMetricRegistration<RLC>>(self, metrics...
  function text_metrics_episode (line 182) | pub fn text_metrics_episode<Me: EpisodeTextMetricRegistration<RLC>>(self...
  function text_metric_train (line 187) | pub fn text_metric_train<Me: Metric + 'static>(mut self, metric: Me) -> ...
  function metric_train (line 196) | pub fn metric_train<Me>(mut self, metric: Me) -> Self
  function text_metric_agent (line 207) | pub fn text_metric_agent<Me: Metric + 'static>(mut self, metric: Me) -> ...
  function metric_agent (line 217) | pub fn metric_agent<Me>(mut self, metric: Me) -> Self
  function text_metric_episode (line 229) | pub fn text_metric_episode<Me: Metric + 'static>(mut self, metric: Me) -...
  function metric_episode (line 239) | pub fn metric_episode<Me>(mut self, metric: Me) -> Self
  function num_steps (line 251) | pub fn num_steps(mut self, num_steps: usize) -> Self {
  function checkpoint (line 257) | pub fn checkpoint(mut self, checkpoint: usize) -> Self {
  function interrupter (line 263) | pub fn interrupter(&self) -> Interrupter {
  function with_interrupter (line 268) | pub fn with_interrupter(mut self, interrupter: Interrupter) -> Self {
  function with_application_logger (line 276) | pub fn with_application_logger(
  function with_file_checkpointer (line 286) | pub fn with_file_checkpointer<FR>(mut self, recorder: FR) -> Self
  function summary (line 308) | pub fn summary(mut self) -> Self {
  function launch (line 314) | pub fn launch(mut self, learner_agent: RLC::LearningAgent) -> RLResult<R...
  type RLResult (line 377) | pub struct RLResult<P> {
  type AgentMetricRegistration (line 385) | pub trait AgentMetricRegistration<RLC: RLComponentsTypes>: Sized {
    method register (line 387) | fn register(self, builder: RLTraining<RLC>) -> RLTraining<RLC>;
  type AgentTextMetricRegistration (line 391) | pub trait AgentTextMetricRegistration<RLC: RLComponentsTypes>: Sized {
    method register (line 393) | fn register(self, builder: RLTraining<RLC>) -> RLTraining<RLC>;
  type TrainMetricRegistration (line 397) | pub trait TrainMetricRegistration<RLC: RLComponentsTypes>: Sized {
    method register (line 399) | fn register(self, builder: RLTraining<RLC>) -> RLTraining<RLC>;
  type TrainTextMetricRegistration (line 403) | pub trait TrainTextMetricRegistration<RLC: RLComponentsTypes>: Sized {
    method register (line 405) | fn register(self, builder: RLTraining<RLC>) -> RLTraining<RLC>;
  type EpisodeMetricRegistration (line 409) | pub trait EpisodeMetricRegistration<RLC: RLComponentsTypes>: Sized {
    method register (line 411) | fn register(self, builder: RLTraining<RLC>) -> RLTraining<RLC>;
  type EpisodeTextMetricRegistration (line 415) | pub trait EpisodeTextMetricRegistration<RLC: RLComponentsTypes>: Sized {
    method register (line 417) | fn register(self, builder: RLTraining<RLC>) -> RLTraining<RLC>;

FILE: crates/burn-train/src/learner/rl/strategy.rs
  type RLComponents (line 10) | pub struct RLComponents<RLC: RLComponentsTypes> {
  type RLStrategies (line 31) | pub enum RLStrategies<RLC: RLComponentsTypes> {
  type CustomRLStrategy (line 39) | pub type CustomRLStrategy<LC> = Arc<dyn RLStrategy<LC>>;
  type RLStrategy (line 42) | pub trait RLStrategy<RLC: RLComponentsTypes> {
    method train (line 44) | fn train(
    method train_loop (line 92) | fn train_loop(

FILE: crates/burn-train/src/learner/sequence.rs
  type SequenceOutput (line 17) | pub struct SequenceOutput<B: Backend> {
  function predicted_tokens (line 33) | fn predicted_tokens(&self) -> Tensor<B, 2, Int> {
  function flat_logits (line 40) | fn flat_logits(&self) -> Tensor<B, 2> {
  function flat_targets (line 47) | fn flat_targets(&self) -> Tensor<B, 1, Int> {
  type ItemSync (line 54) | type ItemSync = SequenceOutput<NdArray>;
  method sync (line 56) | fn sync(self) -> Self::ItemSync {
  function adapt (line 98) | fn adapt(&self) -> LossInput<B> {
  function adapt (line 104) | fn adapt(&self) -> CerInput<B> {
  function adapt (line 110) | fn adapt(&self) -> WerInput<B> {
  function adapt (line 116) | fn adapt(&self) -> AccuracyInput<B> {
  function adapt (line 122) | fn adapt(&self) -> TopKAccuracyInput<B> {
  function adapt (line 128) | fn adapt(&self) -> PerplexityInput<B> {

FILE: crates/burn-train/src/learner/summary.rs
  type MetricEntry (line 15) | pub struct MetricEntry {
  type MetricSummary (line 24) | pub struct MetricSummary {
    method collect (line 32) | fn collect<E: EventStore>(
  type SummaryMetrics (line 58) | pub struct SummaryMetrics {
  type LearnerSummary (line 71) | pub struct LearnerSummary {
    method new (line 87) | pub fn new<S: AsRef<str>>(directory: impl AsRef<Path>, metrics: &[S]) ...
    method with_model (line 147) | pub(crate) fn with_model(mut self, name: String) -> Self {
    method merge (line 153) | pub(crate) fn merge(mut self, other: LearnerSummary) -> Self {
  function collect_test_split_metrics (line 198) | fn collect_test_split_metrics<P: AsRef<Path>, S: AsRef<str>>(
  method fmt (line 262) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type LearnerSummaryConfig (line 388) | pub struct LearnerSummaryConfig {
    method init (line 395) | pub fn init(&self) -> Result<LearnerSummary, String> {
  function test_artifact_dir_should_exist (line 406) | fn test_artifact_dir_should_exist() {
  function test_train_valid_artifacts_should_exist (line 413) | fn test_train_valid_artifacts_should_exist() {
  function test_summary_should_be_empty (line 420) | fn test_summary_should_be_empty() {
  function test_summary_should_be_collected (line 437) | fn test_summary_should_be_collected() {

FILE: crates/burn-train/src/learner/supervised/paradigm.rs
  type TrainLoader (line 36) | pub type TrainLoader<LC> = Arc<dyn DataLoader<TrainingBackend<LC>, Train...
  type ValidLoader (line 38) | pub type ValidLoader<LC> = Arc<dyn DataLoader<InferenceBackend<LC>, Infe...
  type SupervisedTrainingEventProcessor (line 40) | pub type SupervisedTrainingEventProcessor<LC> = AsyncProcessorTraining<
  type SupervisedTraining (line 46) | pub struct SupervisedTraining<LC>
  function new (line 91) | pub fn new(
  function with_training_strategy (line 140) | pub fn with_training_strategy(mut self, training_strategy: TrainingStrat...
  function with_metric_logger (line 150) | pub fn with_metric_logger<ML>(mut self, logger: ML) -> Self
  function with_checkpointing_strategy (line 159) | pub fn with_checkpointing_strategy<CS: CheckpointingStrategy + 'static>(
  function renderer (line 172) | pub fn renderer<MR>(mut self, renderer: MR) -> Self
  function metrics (line 181) | pub fn metrics<Me: MetricRegistration<LC>>(self, metrics: Me) -> Self {
  function metrics_text (line 186) | pub fn metrics_text<Me: TextMetricRegistration<LC>>(self, metrics: Me) -...
  function metric_train (line 191) | pub fn metric_train<Me: Metric + 'static>(mut self, metric: Me) -> Self
  function metric_valid (line 200) | pub fn metric_valid<Me: Metric + 'static>(mut self, metric: Me) -> Self
  function grads_accumulation (line 218) | pub fn grads_accumulation(mut self, accumulation: usize) -> Self {
  function metric_train_numeric (line 224) | pub fn metric_train_numeric<Me>(mut self, metric: Me) -> Self
  function metric_valid_numeric (line 235) | pub fn metric_valid_numeric<Me: Metric + Numeric + 'static>(mut self, me...
  function num_epochs (line 245) | pub fn num_epochs(mut self, num_epochs: usize) -> Self {
  function checkpoint (line 251) | pub fn checkpoint(mut self, checkpoint: usize) -> Self {
  function interrupter (line 257) | pub fn interrupter(&self) -> Interrupter {
  function with_interrupter (line 262) | pub fn with_interrupter(mut self, interrupter: Interrupter) -> Self {
  function early_stopping (line 269) | pub fn early_stopping<Strategy>(mut self, strategy: Strategy) -> Self
  function with_application_logger (line 280) | pub fn with_application_logger(
  function with_file_checkpointer (line 290) | pub fn with_file_checkpointer<FR>(mut self, recorder: FR) -> Self
  function summary (line 316) | pub fn summary(mut self) -> Self {
  function launch (line 324) | pub fn launch(mut self, learner: Learner<LC>) -> LearningResult<Inferenc...
  type MetricRegistration (line 432) | pub trait MetricRegistration<LC: LearningComponentsTypes>: Sized {
    method register (line 434) | fn register(self, builder: SupervisedTraining<LC>) -> SupervisedTraini...
  type TextMetricRegistration (line 438) | pub trait TextMetricRegistration<LC: LearningComponentsTypes>: Sized {
    method register (line 440) | fn register(self, builder: SupervisedTraining<LC>) -> SupervisedTraini...

FILE: crates/burn-train/src/learner/supervised/step/train.rs
  type MultiDevicesTrainStep (line 13) | pub struct MultiDevicesTrainStep<LC: LearningComponentsTypes> {
  type Message (line 18) | struct Message<M, TI> {
  type Worker (line 23) | struct Worker<LC: LearningComponentsTypes> {
  function register (line 31) | fn register(&self, item: TrainingModelInput<LC>, model: &TrainingModel<L...
  function start (line 41) | fn start(
  type MultiTrainOutput (line 72) | pub struct MultiTrainOutput<TO> {
  function new (line 89) | pub fn new(devices: &[Device<TrainingBackend<LC>>]) -> Self {
  function step (line 121) | pub fn step<'a>(

FILE: crates/burn-train/src/learner/supervised/strategies/base.rs
  type LearnerDevice (line 18) | type LearnerDevice<LC> = <<LC as LearningComponentsTypes>::Backend as Ba...
  type CustomLearningStrategy (line 21) | pub type CustomLearningStrategy<LC> = Arc<dyn SupervisedLearningStrategy...
  type MultiDeviceOptim (line 25) | pub enum MultiDeviceOptim {
  type TrainingStrategy (line 34) | pub enum TrainingStrategy<LC: LearningComponentsTypes> {
  function ddp (line 57) | pub fn ddp<LC: LearningComponentsTypes>(
  method default (line 65) | fn default() -> Self {
  type TrainingComponents (line 72) | pub struct TrainingComponents<LC: LearningComponentsTypes> {
  type SupervisedLearningStrategy (line 94) | pub trait SupervisedLearningStrategy<LC: LearningComponentsTypes> {
    method train (line 96) | fn train(
    method fit (line 146) | fn fit(

FILE: crates/burn-train/src/learner/supervised/strategies/ddp/epoch.rs
  type DdpValidEpoch (line 20) | pub struct DdpValidEpoch<LC: LearningComponentsTypes> {
  type DdpTrainEpoch (line 26) | pub struct DdpTrainEpoch<LC: LearningComponentsTypes> {
  function run (line 38) | pub fn run(
  function run (line 90) | pub fn run(
  type GradsSyncer (line 181) | struct GradsSyncer<B: AutodiffBackend, M: AutodiffModule<B> + 'static> {
  function new (line 190) | fn new(double_buffering: bool, peer_id: PeerId) -> Self {
  function sync (line 204) | fn sync(&self, grads: GradientsParams) -> Option<GradientsParams> {
  function run_worker (line 209) | fn run_worker(

FILE: crates/burn-train/src/learner/supervised/strategies/ddp/strategy.rs
  type WorkerComponents (line 18) | pub(crate) struct WorkerComponents {
  type DdpTrainingStrategy (line 31) | pub struct DdpTrainingStrategy<LC: LearningComponentsTypes> {
  function new (line 36) | pub fn new(devices: Vec<Device<TrainingBackend<LC>>>, config: Collective...
  function fit (line 45) | fn fit(

FILE: crates/burn-train/src/learner/supervised/strategies/ddp/worker.rs
  type DdpWorker (line 16) | pub(crate) struct DdpWorker<LC>
  function start (line 40) | pub fn start(
  function fit (line 73) | pub fn fit(mut self) -> <LC as LearningComponentsTypes>::TrainingModel {

FILE: crates/burn-train/src/learner/supervised/strategies/multi/epoch.rs
  type MultiDeviceTrainEpoch (line 18) | pub struct MultiDeviceTrainEpoch<LC: LearningComponentsTypes> {
  function run (line 38) | pub fn run(
  function run_optim_main (line 65) | fn run_optim_main(
  function run_optim_distr (line 139) | fn run_optim_distr(

FILE: crates/burn-train/src/learner/supervised/strategies/multi/strategy.rs
  type MultiDeviceLearningStrategy (line 13) | pub struct MultiDeviceLearningStrategy<LC: LearningComponentsTypes> {
  function new (line 18) | pub fn new(devices: Vec<Device<TrainingBackend<LC>>>, optim: MultiDevice...
  function fit (line 26) | fn fit(

FILE: crates/burn-train/src/learner/supervised/strategies/single/epoch.rs
  type SingleDeviceValidEpoch (line 13) | pub struct SingleDeviceValidEpoch<LC: LearningComponentsTypes> {
  type SingleDeviceTrainEpoch (line 19) | pub struct SingleDeviceTrainEpoch<LC: LearningComponentsTypes> {
  function run (line 31) | pub fn run(
  function run (line 81) | pub fn run(

FILE: crates/burn-train/src/learner/supervised/strategies/single/strategy.rs
  type SingleDeviceTrainingStrategy (line 13) | pub struct SingleDeviceTrainingStrategy<LC: LearningComponentsTypes> {
  function new (line 17) | pub fn new(device: Device<TrainingBackend<LC>>) -> Self {
  type TrainingLoop (line 23) | pub(crate) struct TrainingLoop {
  type Item (line 30) | type Item = Progress;
  method next (line 32) | fn next(&mut self) -> Option<Self::Item> {
  function fit (line 50) | fn fit(

FILE: crates/burn-train/src/learner/train_val.rs
  type TrainOutput (line 7) | pub struct TrainOutput<TO> {
  function new (line 27) | pub fn new<B: AutodiffBackend, M: AutodiffModule<B>>(
  type TrainStep (line 50) | pub trait TrainStep {
    method step (line 64) | fn step(&self, item: Self::Input) -> TrainOutput<Self::Output>;
    method optimize (line 76) | fn optimize<B, O>(self, optim: &mut O, lr: f64, grads: GradientsParams...
    method optimize_multi (line 95) | fn optimize_multi<B, O>(self, optim: &mut O, lr: f64, grads: MultiGrad...
  type InferenceStep (line 106) | pub trait InferenceStep {
    method step (line 120) | fn step(&self, item: Self::Input) -> Self::Output;
  type LearningResult (line 124) | pub struct LearningResult<M> {

FILE: crates/burn-train/src/lib.rs
  type TestBackend (line 36) | pub(crate) type TestBackend = burn_ndarray::NdArray<f32>;
  type TestAutodiffBackend (line 44) | pub type TestAutodiffBackend = burn_autodiff::Autodiff<TestBackend>;
  constant THRESHOLD (line 47) | pub const THRESHOLD: f64 = 0.5;
  type ClassificationType (line 50) | pub enum ClassificationType {
  function dummy_classification_input (line 59) | pub fn dummy_classification_input(

FILE: crates/burn-train/src/logger/async_logger.rs
  type Message (line 4) | enum Message<T> {
  type AsyncLogger (line 10) | pub struct AsyncLogger<T> {
  type LoggerThread (line 16) | struct LoggerThread<T, L: Logger<T>> {
  function run (line 25) | fn run(mut self) {
  function new (line 46) | pub fn new<L>(logger: L) -> Self
  function sync (line 59) | pub(crate) fn sync(&self) {
  function log (line 73) | fn log(&mut self, item: T) {
  method drop (line 81) | fn drop(&mut self) {

FILE: crates/burn-train/src/logger/base.rs
  type Logger (line 2) | pub trait Logger<T>: Send {
    method log (line 8) | fn log(&mut self, item: T);

FILE: crates/burn-train/src/logger/file.rs
  type FileLogger (line 5) | pub struct FileLogger {
    method new (line 19) | pub fn new(path: impl AsRef<Path>) -> Self {
    method log (line 43) | fn log(&mut self, item: T) {

FILE: crates/burn-train/src/logger/in_memory.rs
  type InMemoryLogger (line 5) | pub struct InMemoryLogger {
    method log (line 13) | fn log(&mut self, item: T) {

FILE: crates/burn-train/src/logger/metric.rs
  constant EPOCH_PREFIX (line 12) | const EPOCH_PREFIX: &str = "epoch-";
  type MetricLogger (line 15) | pub trait MetricLogger: Send {
    method log (line 23) | fn log(&mut self, update: MetricsUpdate, epoch: usize, split: &Split);
    method read_numeric (line 26) | fn read_numeric(
    method log_metric_definition (line 34) | fn log_metric_definition(&mut self, definition: MetricDefinition);
    method log_epoch_summary (line 37) | fn log_epoch_summary(&mut self, summary: EpochSummary);
    method log (line 214) | fn log(&mut self, update: MetricsUpdate, epoch: usize, split: &Split) {
    method read_numeric (line 237) | fn read_numeric(
    method log_metric_definition (line 277) | fn log_metric_definition(&mut self, definition: MetricDefinition) {
    method log_epoch_summary (line 282) | fn log_epoch_summary(&mut self, _summary: EpochSummary) {
    method log (line 309) | fn log(&mut self, update: MetricsUpdate, epoch: usize, split: &Split) {
    method read_numeric (line 347) | fn read_numeric(
    method log_metric_definition (line 369) | fn log_metric_definition(&mut self, definition: MetricDefinition) {
    method log_epoch_summary (line 374) | fn log_epoch_summary(&mut self, _summary: EpochSummary) {}
  type FileMetricLogger (line 41) | pub struct FileMetricLogger {
    method new (line 59) | pub fn new(directory: impl AsRef<Path>) -> Self {
    method new_eval (line 78) | pub fn new_eval(directory: impl AsRef<Path>) -> Self {
    method split_exists (line 88) | pub(crate) fn split_exists(&self, split: &Split) -> bool {
    method split_dir (line 92) | pub(crate) fn split_dir(&self, split: &Split) -> Option<PathBuf> {
    method is_epoch_dir (line 100) | pub(crate) fn is_epoch_dir<P: AsRef<str>>(dirname: P) -> bool {
    method epochs (line 105) | pub(crate) fn epochs(&self) -> usize {
    method train_directory (line 143) | fn train_directory(&self, epoch: usize, split: &Split) -> PathBuf {
    method eval_directory (line 157) | fn eval_directory(&self, split: &Split) -> PathBuf {
    method file_path (line 164) | fn file_path(&self, name: &str, epoch: Option<usize>, split: &Split) -...
    method create_directory (line 174) | fn create_directory(&self, epoch: Option<usize>, split: &Split) {
    method log_item (line 184) | fn log_item(&mut self, item: &MetricEntry, epoch: Option<usize>, split...
  function format_tag (line 209) | fn format_tag(tag: &str) -> String {
  function logger_key (line 289) | fn logger_key(name: &str, split: &Split) -> String {
  type InMemoryMetricLogger (line 295) | pub struct InMemoryMetricLogger {
    method new (line 303) | pub fn new() -> Self {

FILE: crates/burn-train/src/metric/acc.rs
  type AccuracyMetric (line 11) | pub struct AccuracyMetric<B: Backend> {
  type AccuracyInput (line 20) | pub struct AccuracyInput<B: Backend> {
  method default (line 26) | fn default() -> Self {
  function new (line 33) | pub fn new() -> Self {
  function with_pad_token (line 43) | pub fn with_pad_token(mut self, index: usize) -> Self {
  type Input (line 50) | type Input = AccuracyInput<B>;
  method update (line 52) | fn update(&mut self, input: &AccuracyInput<B>, _metadata: &MetricMetadat...
  method clear (line 88) | fn clear(&mut self) {
  method name (line 92) | fn name(&self) -> MetricName {
  method attributes (line 96) | fn attributes(&self) -> MetricAttributes {
  method value (line 106) | fn value(&self) -> super::NumericEntry {
  method running_value (line 110) | fn running_value(&self) -> super::NumericEntry {
  function test_accuracy_without_padding (line 121) | fn test_accuracy_without_padding() {
  function test_accuracy_with_padding (line 142) | fn test_accuracy_with_padding() {

FILE: crates/burn-train/src/metric/auroc.rs
  type AurocMetric (line 12) | pub struct AurocMetric<B: Backend> {
  type AurocInput (line 20) | pub struct AurocInput<B: Backend> {
  method default (line 26) | fn default() -> Self {
  function new (line 33) | pub fn new() -> Self {
  function binary_auroc (line 41) | fn binary_auroc(&self, probabilities: &Tensor<B, 1>, targets: &Tensor<B,...
  type Input (line 81) | type Input = AurocInput<B>;
  method update (line 83) | fn update(&mut self, input: &AurocInput<B>, _metadata: &MetricMetadata) ...
  method clear (line 108) | fn clear(&mut self) {
  method name (line 112) | fn name(&self) -> MetricName {
  method value (line 118) | fn value(&self) -> super::NumericEntry {
  method running_value (line 122) | fn running_value(&self) -> super::NumericEntry {
  function test_auroc (line 133) | fn test_auroc() {
  function test_auroc_perfect_separation (line 155) | fn test_auroc_perfect_separation() {
  function test_auroc_random (line 169) | fn test_auroc_random() {
  function test_auroc_all_one_class (line 191) | fn test_auroc_all_one_class() {
  function test_auroc_multiclass_error (line 214) | fn test_auroc_multiclass_error() {

FILE: crates/burn-train/src/metric/base.rs
  type MetricMetadata (line 7) | pub struct MetricMetadata {
    method fake (line 24) | pub fn fake() -> Self {
  type MetricId (line 43) | pub struct MetricId {
  type MetricAttributes (line 50) | pub enum MetricAttributes {
    method from (line 146) | fn from(attr: NumericAttributes) -> Self {
  type MetricDefinition (line 59) | pub struct MetricDefinition {
    method new (line 72) | pub fn new<Me: Metric>(metric_id: MetricId, metric: &Me) -> Self {
  type Metric (line 89) | pub trait Metric: Send + Sync + Clone {
    method name (line 99) | fn name(&self) -> MetricName;
    method description (line 102) | fn description(&self) -> Option<String> {
    method attributes (line 109) | fn attributes(&self) -> MetricAttributes {
    method update (line 114) | fn update(&mut self, item: &Self::Input, metadata: &MetricMetadata) ->...
    method clear (line 117) | fn clear(&mut self);
  type MetricName (line 121) | pub type MetricName = Arc<String>;
  type Adaptor (line 127) | pub trait Adaptor<T> {
    method adapt (line 129) | fn adapt(&self) -> T;
  method adapt (line 133) | fn adapt(&self) {}
  type NumericAttributes (line 138) | pub struct NumericAttributes {
  method default (line 152) | fn default() -> Self {
  type Numeric (line 163) | pub trait Numeric {
    method value (line 165) | fn value(&self) -> NumericEntry;
    method running_value (line 167) | fn running_value(&self) -> NumericEntry;
  type SerializedEntry (line 172) | pub struct SerializedEntry {
  type MetricEntry (line 181) | pub struct MetricEntry {
    method new (line 190) | pub fn new(metric_id: MetricId, serialized_entry: SerializedEntry) -> ...
  type NumericEntry (line 200) | pub enum NumericEntry {
    method current (line 214) | pub fn current(&self) -> f64 {
    method serialize (line 224) | pub fn serialize(&self) -> String {
    method deserialize (line 235) | pub fn deserialize(entry: &str) -> Result<Self, String> {
    method better_than (line 265) | pub fn better_than(&self, other: &NumericEntry, higher_is_better: bool...
  function format_float (line 271) | pub fn format_float(float: f64, precision: usize) -> String {

FILE: crates/burn-train/src/metric/cer.rs
  function edit_distance (line 15) | pub(crate) fn edit_distance(reference: &[i32], prediction: &[i32]) -> us...
  type CharErrorRate (line 39) | pub struct CharErrorRate<B: Backend> {
  type CerInput (line 48) | pub struct CerInput<B: Backend> {
  method default (line 56) | fn default() -> Self {
  function new (line 63) | pub fn new() -> Self {
  function with_pad_token (line 73) | pub fn with_pad_token(mut self, index: usize) -> Self {
  type Input (line 81) | type Input = CerInput<B>;
  method update (line 83) | fn update(&mut self, input: &CerInput<B>, _metadata: &MetricMetadata) ->...
  method clear (line 143) | fn clear(&mut self) {
  method name (line 147) | fn name(&self) -> MetricName {
  method attributes (line 151) | fn attributes(&self) -> MetricAttributes {
  method value (line 161) | fn value(&self) -> NumericEntry {
  method running_value (line 165) | fn running_value(&self) -> NumericEntry {
  function test_cer_without_padding (line 177) | fn test_cer_without_padding() {
  function test_cer_without_padding_two_errors (line 192) | fn test_cer_without_padding_two_errors() {
  function test_cer_with_padding (line 208) | fn test_cer_with_padding() {
  function test_clear_resets_state (line 223) | fn test_clear_resets_state() {

FILE: crates/burn-train/src/metric/classification.rs
  type ClassificationMetricConfig (line 5) | pub struct ClassificationMetricConfig {
  type DecisionRule (line 12) | pub enum DecisionRule {
  method default (line 20) | fn default() -> Self {
  type ClassReduction (line 27) | pub enum ClassReduction {

FILE: crates/burn-train/src/metric/confusion_stats.rs
  type ConfusionStatsInput (line 10) | pub struct ConfusionStatsInput<B: Backend> {
  function from (line 18) | fn from(input: ConfusionStatsInput<B>) -> Self {
  function from (line 24) | fn from(value: (Tensor<B, 2>, Tensor<B, 2, Bool>)) -> Self {
  type ConfusionStats (line 30) | pub struct ConfusionStats<B: Backend> {
  method fmt (line 36) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 57) | pub fn new(input: &ConfusionStatsInput<B>, config: &ClassificationMetric...
  function aggregate (line 80) | fn aggregate(
  function true_positive (line 91) | pub fn true_positive(self) -> Tensor<B, 1> {
  function true_negative (line 95) | pub fn true_negative(self) -> Tensor<B, 1> {
  function false_positive (line 99) | pub fn false_positive(self) -> Tensor<B, 1> {
  function false_negative (line 103) | pub fn false_negative(self) -> Tensor<B, 1> {
  function positive (line 107) | pub fn positive(self) -> Tensor<B, 1> {
  function negative (line 111) | pub fn negative(self) -> Tensor<B, 1> {
  function predicted_positive (line 115) | pub fn predicted_positive(self) -> Tensor<B, 1> {
  function support (line 119) | pub fn support(self) -> Tensor<B, 1> {
  function ratio_of_support (line 123) | pub fn ratio_of_support(self, metric: Tensor<B, 1>) -> Tensor<B, 1> {
  function top_k_config (line 140) | fn top_k_config(
  function top_k_config_k1_micro (line 151) | fn top_k_config_k1_micro() -> ClassificationMetricConfig {
  function top_k_config_k1_macro (line 157) | fn top_k_config_k1_macro() -> ClassificationMetricConfig {
  function top_k_config_k2_micro (line 162) | fn top_k_config_k2_micro() -> ClassificationMetricConfig {
  function top_k_config_k2_macro (line 167) | fn top_k_config_k2_macro() -> ClassificationMetricConfig {
  function threshold_config (line 171) | fn threshold_config(
  function threshold_config_micro (line 182) | fn threshold_config_micro() -> ClassificationMetricConfig {
  function threshold_config_macro (line 187) | fn threshold_config_macro() -> ClassificationMetricConfig {
  function test_true_positive (line 200) | fn test_true_positive(
  function test_true_negative (line 223) | fn test_true_negative(
  function test_false_positive (line 246) | fn test_false_positive(
  function test_false_negatives (line 269) | fn test_false_negatives(
  function test_positive (line 292) | fn test_positive(
  function test_negative (line 315) | fn test_negative(
  function test_predicted_positive (line 338) | fn test_predicted_positive(

FILE: crates/burn-train/src/metric/cpu_temp.rs
  type CpuTemperature (line 10) | pub struct CpuTemperature {
    method new (line 18) | pub fn new() -> Self {
  method default (line 30) | fn default() -> Self {
  type Input (line 36) | type Input = ();
  method update (line 38) | fn update(&mut self, _item: &Self::Input, _metadata: &MetricMetadata) ->...
  method clear (line 53) | fn clear(&mut self) {}
  method name (line 55) | fn name(&self) -> MetricName {
  method attributes (line 59) | fn attributes(&self) -> MetricAttributes {
  method value (line 69) | fn value(&self) -> NumericEntry {
  method running_value (line 73) | fn running_value(&self) -> NumericEntry {

FILE: crates/burn-train/src/metric/cpu_use.rs
  type CpuUse (line 10) | pub struct CpuUse {
    method new (line 32) | pub fn new() -> Self {
    method refresh (line 46) | fn refresh(sys: &mut System) -> f64 {
  method clone (line 19) | fn clone(&self) -> Self {
  method default (line 60) | fn default() -> Self {
  type Input (line 66) | type Input = ();
  method update (line 68) | fn update(&mut self, _item: &Self::Input, _metadata: &MetricMetadata) ->...
  method clear (line 80) | fn clear(&mut self) {}
  method name (line 82) | fn name(&self) -> MetricName {
  method attributes (line 86) | fn attributes(&self) -> MetricAttributes {
  method value (line 96) | fn value(&self) -> NumericEntry {
  method running_value (line 100) | fn running_value(&self) -> NumericEntry {

FILE: crates/burn-train/src/metric/cuda.rs
  type CudaMetric (line 9) | pub struct CudaMetric {
    method new (line 16) | pub fn new() -> Self {
  method default (line 28) | fn default() -> Self {
  type Input (line 34) | type Input = ();
  method update (line 36) | fn update(&mut self, _item: &(), _metadata: &MetricMetadata) -> Serializ...
  method clear (line 103) | fn clear(&mut self) {}
  method name (line 105) | fn name(&self) -> MetricName {

FILE: crates/burn-train/src/metric/fbetascore.rs
  type FBetaScoreMetric (line 21) | pub struct FBetaScoreMetric<B: Backend> {
  method default (line 30) | fn default() -> Self {
  function new (line 37) | fn new(config: ClassificationMetricConfig, beta: f64) -> Self {
  function binary (line 58) | pub fn binary(beta: f64, threshold: f64) -> Self {
  function multiclass (line 77) | pub fn multiclass(beta: f64, top_k: usize, class_reduction: ClassReducti...
  function multilabel (line 97) | pub fn multilabel(beta: f64, threshold: f64, class_reduction: ClassReduc...
  function class_average (line 107) | fn class_average(&self, mut aggregated_metric: Tensor<B, 1>) -> f64 {
  type Input (line 132) | type Input = ConfusionStatsInput<B>;
  method update (line 134) | fn update(&mut self, input: &Self::Input, _metadata: &MetricMetadata) ->...
  method clear (line 153) | fn clear(&mut self) {
  method name (line 157) | fn name(&self) -> MetricName {
  method attributes (line 161) | fn attributes(&self) -> MetricAttributes {
  method value (line 171) | fn value(&self) -> NumericEntry {
  method running_value (line 175) | fn running_value(&self) -> NumericEntry {
  function test_binary_fscore (line 198) | fn test_binary_fscore(#[case] beta: f64, #[case] threshold: f64, #[case]...
  function test_multiclass_fscore (line 215) | fn test_multiclass_fscore(
  function test_multilabel_fscore (line 233) | fn test_multilabel_fscore(
  function test_parameterized_unique_name (line 247) | fn test_parameterized_unique_name() {

FILE: crates/burn-train/src/metric/hamming.rs
  type HammingScore (line 13) | pub struct HammingScore<B: Backend> {
  type HammingScoreInput (line 23) | pub struct HammingScoreInput<B: Backend> {
  function new (line 30) | pub fn new() -> Self {
  function update_name (line 34) | fn update_name(&mut self) {
  function with_threshold (line 39) | pub fn with_threshold(mut self, threshold: f32) -> Self {
  function with_sigmoid (line 46) | pub fn with_sigmoid(mut self, sigmoid: bool) -> Self {
  method default (line 55) | fn default() -> Self {
  type Input (line 70) | type Input = HammingScoreInput<B>;
  method update (line 72) | fn update(
  method clear (line 102) | fn clear(&mut self) {
  method name (line 106) | fn name(&self) -> MetricName {
  method attributes (line 110) | fn attributes(&self) -> MetricAttributes {
  method value (line 120) | fn value(&self) -> NumericEntry {
  method running_value (line 124) | fn running_value(&self) -> NumericEntry {
  function test_hamming_score (line 135) | fn test_hamming_score() {
  function test_parameterized_unique_name (line 190) | fn test_parameterized_unique_name() {

FILE: crates/burn-train/src/metric/iteration.rs
  type IterationSpeedMetric (line 13) | pub struct IterationSpeedMetric {
    method new (line 27) | pub fn new() -> Self {
  method default (line 20) | fn default() -> Self {
  type Input (line 37) | type Input = ();
  method update (line 39) | fn update(&mut self, _: &Self::Input, metadata: &MetricMetadata) -> Seri...
  method clear (line 64) | fn clear(&mut self) {
  method name (line 68) | fn name(&self) -> MetricName {
  method attributes (line 72) | fn attributes(&self) -> MetricAttributes {
  method value (line 82) | fn value(&self) -> NumericEntry {
  method running_value (line 86) | fn running_value(&self) -> NumericEntry {

FILE: crates/burn-train/src/metric/learning_rate.rs
  type LearningRateMetric (line 11) | pub struct LearningRateMetric {
    method new (line 18) | pub fn new() -> Self {
  method default (line 27) | fn default() -> Self {
  type Input (line 33) | type Input = ();
  method update (line 35) | fn update(&mut self, _item: &(), metadata: &MetricMetadata) -> Serialize...
  method clear (line 42) | fn clear(&mut self) {
  method name (line 46) | fn name(&self) -> MetricName {
  method attributes (line 50) | fn attributes(&self) -> MetricAttributes {
  method value (line 60) | fn value(&self) -> NumericEntry {
  method running_value (line 64) | fn running_value(&self) -> NumericEntry {

FILE: crates/burn-train/src/metric/loss.rs
  type LossMetric (line 14) | pub struct LossMetric<B: Backend> {
  type LossInput (line 22) | pub struct LossInput<B: Backend> {
  method default (line 27) | fn default() -> Self {
  function new (line 34) | pub fn new() -> Self {
  type Input (line 44) | type Input = LossInput<B>;
  method update (line 46) | fn update(&mut self, loss: &Self::Input, _metadata: &MetricMetadata) -> ...
  method clear (line 64) | fn clear(&mut self) {
  method name (line 68) | fn name(&self) -> MetricName {
  method attributes (line 72) | fn attributes(&self) -> MetricAttributes {
  method value (line 82) | fn value(&self) -> NumericEntry {
  method running_value (line 86) | fn running_value(&self) -> NumericEntry {

FILE: crates/burn-train/src/metric/memory_use.rs
  type CpuMemory (line 11) | pub struct CpuMemory {
    method new (line 35) | pub fn new() -> Self {
    method refresh (line 48) | fn refresh(&mut self) {
  method clone (line 21) | fn clone(&self) -> Self {
  method default (line 61) | fn default() -> Self {
  type Input (line 67) | type Input = ();
  method update (line 69) | fn update(&mut self, _item: &Self::Input, _metadata: &MetricMetadata) ->...
  method clear (line 84) | fn clear(&mut self) {}
  method name (line 86) | fn name(&self) -> Arc<String> {
  method attributes (line 90) | fn attributes(&self) -> MetricAttributes {
  method value (line 100) | fn value(&self) -> NumericEntry {
  method running_value (line 104) | fn running_value(&self) -> NumericEntry {
  function bytes2gb (line 109) | fn bytes2gb(bytes: u64) -> f64 {

FILE: crates/burn-train/src/metric/perplexity.rs
  type PerplexityState (line 16) | struct PerplexityState {
    method new (line 26) | fn new() -> Self {
    method reset (line 34) | fn reset(&mut self) {
    method update (line 41) | fn update(
    method value (line 96) | fn value(&self) -> NumericEntry {
    method running_value (line 109) | fn running_value(&self) -> NumericEntry {
  type PerplexityMetric (line 133) | pub struct PerplexityMetric<B: Backend> {
  type PerplexityInput (line 142) | pub struct PerplexityInput<B: Backend> {
  method default (line 150) | fn default() -> Self {
  function new (line 157) | pub fn new() -> Self {
  function with_pad_token (line 171) | pub fn with_pad_token(mut self, index: usize) -> Self {
  type Input (line 178) | type Input = PerplexityInput<B>;
  method update (line 180) | fn update(
  method clear (line 228) | fn clear(&mut self) {
  method name (line 232) | fn name(&self) -> MetricName {
  method attributes (line 236) | fn attributes(&self) -> MetricAttributes {
  method value (line 246) | fn value(&self) -> NumericEntry {
  method running_value (line 250) | fn running_value(&self) -> NumericEntry {
  function test_perplexity_perfect_prediction (line 261) | fn test_perplexity_perfect_prediction() {
  function test_perplexity_uniform_prediction (line 290) | fn test_perplexity_uniform_prediction() {
  function test_perplexity_with_padding (line 319) | fn test_perplexity_with_padding() {
  function test_perplexity_wrong_prediction (line 348) | fn test_perplexity_wrong_prediction() {
  function test_perplexity_multi_batch_aggregation (line 377) | fn test_perplexity_multi_batch_aggregation() {

FILE: crates/burn-train/src/metric/precision.rs
  type PrecisionMetric (line 18) | pub struct PrecisionMetric<B: Backend> {
  method default (line 26) | fn default() -> Self {
  function new (line 32) | fn new(config: ClassificationMetricConfig) -> Self {
  function binary (line 52) | pub fn binary(threshold: f64) -> Self {
  function multiclass (line 67) | pub fn multiclass(top_k: usize, class_reduction: ClassReduction) -> Self {
  function multilabel (line 83) | pub fn multilabel(threshold: f64, class_reduction: ClassReduction) -> Se...
  function class_average (line 93) | fn class_average(&self, mut aggregated_metric: Tensor<B, 1>) -> f64 {
  type Input (line 118) | type Input = ConfusionStatsInput<B>;
  method update (line 120) | fn update(&mut self, input: &Self::Input, _metadata: &MetricMetadata) ->...
  method clear (line 134) | fn clear(&mut self) {
  method name (line 138) | fn name(&self) -> MetricName {
  method attributes (line 142) | fn attributes(&self) -> MetricAttributes {
  method value (line 152) | fn value(&self) -> NumericEntry {
  method running_value (line 156) | fn running_value(&self) -> NumericEntry {
  function test_binary_precision (line 178) | fn test_binary_precision(#[case] threshold: f64, #[case] expected: f64) {
  function test_multiclass_precision (line 191) | fn test_multiclass_precision(
  function test_multilabel_precision (line 206) | fn test_multilabel_precision(
  function test_parameterized_unique_name (line 219) | fn test_parameterized_unique_name() {

FILE: crates/burn-train/src/metric/processor/async_wrapper.rs
  type AsyncProcessorTraining (line 7) | pub struct AsyncProcessorTraining<ET, EV> {
  type AsyncProcessorEvaluation (line 12) | pub struct AsyncProcessorEvaluation<P: EventProcessorEvaluation> {
  type WorkerTraining (line 16) | struct WorkerTraining<ET, EV, P: EventProcessorTraining<ET, EV>> {
  type WorkerEvaluation (line 21) | struct WorkerEvaluation<P: EventProcessorEvaluation> {
  function start (line 29) | pub fn start(processor: P, rec: Receiver<Message<ET, EV>>) {
  function start (line 49) | pub fn start(processor: P, rec: Receiver<EvalMessage<P>>) {
  function new (line 71) | pub fn new<P: EventProcessorTraining<ET, EV> + 'static>(processor: P) ->...
  function new (line 82) | pub fn new(processor: P) -> Self {
  type Message (line 91) | enum Message<EventTrain, EventValid> {
  type EvalMessage (line 97) | enum EvalMessage<P: EventProcessorEvaluation> {
  function process_train (line 103) | fn process_train(&mut self, event: ET) {
  function process_valid (line 107) | fn process_valid(&mut self, event: EV) {
  function renderer (line 111) | fn renderer(self) -> Box<dyn crate::renderer::MetricsRenderer> {
  type ItemTest (line 125) | type ItemTest = P::ItemTest;
  method process_test (line 127) | fn process_test(&mut self, event: EvaluatorEvent<Self::ItemTest>) {
  method renderer (line 131) | fn renderer(self) -> Box<dyn crate::renderer::MetricsRenderer> {

FILE: crates/burn-train/src/metric/processor/base.rs
  type LearnerEvent (line 10) | pub enum LearnerEvent<T> {
  type EvaluatorEvent (line 22) | pub enum EvaluatorEvent<T> {
  type ItemLazy (line 34) | pub trait ItemLazy: Send {
    method sync (line 39) | fn sync(self) -> Self::ItemSync;
    type ItemSync (line 84) | type ItemSync = TrainingItem<T::ItemSync>;
    method sync (line 86) | fn sync(self) -> Self::ItemSync {
    type ItemSync (line 111) | type ItemSync = EvaluationItem<T::ItemSync>;
    method sync (line 113) | fn sync(self) -> Self::ItemSync {
    type ItemSync (line 123) | type ItemSync = ();
    method sync (line 125) | fn sync(self) -> Self::ItemSync {}
  type EventProcessorTraining (line 43) | pub trait EventProcessorTraining<TrainEvent, ValidEvent>: Send {
    method process_train (line 45) | fn process_train(&mut self, event: TrainEvent);
    method process_valid (line 47) | fn process_valid(&mut self, event: ValidEvent);
    method renderer (line 49) | fn renderer(self) -> Box<dyn MetricsRenderer>;
  type EventProcessorEvaluation (line 53) | pub trait EventProcessorEvaluation: Send {
    method process_test (line 58) | fn process_test(&mut self, event: EvaluatorEvent<Self::ItemTest>);
    method renderer (line 61) | fn renderer(self) -> Box<dyn MetricsRenderer>;
  type TrainingItem (line 66) | pub struct TrainingItem<T> {
  type EvaluationItem (line 99) | pub struct EvaluationItem<T> {

FILE: crates/burn-train/src/metric/processor/full.rs
  type FullEventProcessorTraining (line 12) | pub struct FullEventProcessorTraining<T: ItemLazy, V: ItemLazy> {
  type FullEventProcessorEvaluation (line 21) | pub struct FullEventProcessorEvaluation<T: ItemLazy> {
  function new (line 28) | pub(crate) fn new(
  function progress_indicators (line 40) | fn progress_indicators(&self, progress: &TrainingProgress) -> Vec<Progre...
  function new (line 66) | pub(crate) fn new(
  function progress_indicators (line 78) | fn progress_indicators(&self, progress: &EvaluationProgress) -> Vec<Prog...
  type ItemTest (line 97) | type ItemTest = T;
  method process_test (line 99) | fn process_test(&mut self, event: EvaluatorEvent<Self::ItemTest>) {
  method renderer (line 150) | fn renderer(self) -> Box<dyn MetricsRenderer> {
  function process_train (line 158) | fn process_train(&mut self, event: LearnerEvent<T>) {
  function process_valid (line 212) | fn process_valid(&mut self, event: LearnerEvent<V>) {
  function renderer (line 254) | fn renderer(self) -> Box<dyn MetricsRenderer> {

FILE: crates/burn-train/src/metric/processor/metrics.rs
  type MetricsTraining (line 13) | pub(crate) struct MetricsTraining<T: ItemLazy, V: ItemLazy> {
  type MetricsEvaluation (line 21) | pub(crate) struct MetricsEvaluation<T: ItemLazy> {
  method default (line 28) | fn default() -> Self {
  method default (line 38) | fn default() -> Self {
  function register_test_metric (line 51) | pub(crate) fn register_test_metric<Me: Metric + 'static>(&mut self, metr...
  function register_test_metric_numeric (line 61) | pub(crate) fn register_test_metric_numeric<Me: Metric + Numeric + 'static>(
  function register_definition (line 72) | fn register_definition<Me: Metric>(&mut self, metric: &MetricWrapper<Me>) {
  function metric_definitions (line 80) | pub(crate) fn metric_definitions(&mut self) -> Vec<MetricDefinition> {
  function update_test (line 85) | pub(crate) fn update_test(
  function register_train_metric (line 109) | pub(crate) fn register_train_metric<Me: Metric + 'static>(&mut self, met...
  function register_valid_metric (line 119) | pub(crate) fn register_valid_metric<Me: Metric + 'static>(&mut self, met...
  function register_train_metric_numeric (line 129) | pub(crate) fn register_train_metric_numeric<Me: Metric + Numeric + 'stat...
  function register_valid_metric_numeric (line 141) | pub(crate) fn register_valid_metric_numeric<Me>(&mut self, metric: Me)
  function register_definition (line 151) | fn register_definition<Me: Metric>(&mut self, metric: &MetricWrapper<Me>) {
  function metric_definitions (line 159) | pub(crate) fn metric_definitions(&mut self) -> Vec<MetricDefinition> {
  function update_train (line 164) | pub(crate) fn update_train(
  function update_valid (line 186) | pub(crate) fn update_valid(
  function end_epoch_train (line 208) | pub(crate) fn end_epoch_train(&mut self) {
  function end_epoch_valid (line 218) | pub(crate) fn end_epoch_valid(&mut self) {
  method from (line 229) | fn from(item: &TrainingItem<T>) -> Self {
  method from (line 239) | fn from(item: &EvaluationItem<T>) -> Self {
  method from (line 249) | fn from(item: &EvaluationItem<T>) -> Self {
  method from (line 258) | fn from(item: &TrainingItem<T>) -> Self {
  method from (line 269) | fn from(item: &EvaluationItem<T>) -> Self {
  type NumericMetricUpdater (line 279) | pub(crate) trait NumericMetricUpdater<T>: Send + Sync {
    method update (line 280) | fn update(&mut self, item: &T, metadata: &MetricMetadata) -> NumericMe...
    method clear (line 281) | fn clear(&mut self);
  type MetricUpdater (line 284) | pub(crate) trait MetricUpdater<T>: Send + Sync {
    method update (line 285) | fn update(&mut self, item: &T, metadata: &MetricMetadata) -> MetricEntry;
    method clear (line 286) | fn clear(&mut self);
  type MetricWrapper (line 289) | pub(crate) struct MetricWrapper<M> {
  function new (line 295) | pub fn new(metric: M) -> Self {
  function update (line 309) | fn update(&mut self, item: &T, metadata: &MetricMetadata) -> NumericMetr...
  function clear (line 322) | fn clear(&mut self) {
  function update (line 333) | fn update(&mut self, item: &T, metadata: &MetricMetadata) -> MetricEntry {
  function clear (line 338) | fn clear(&mut self) {

FILE: crates/burn-train/src/metric/processor/minimal.rs
  type MinimalEventProcessor (line 12) | pub(crate) struct MinimalEventProcessor<T: ItemLazy, V: ItemLazy> {
  function process_train (line 20) | fn process_train(&mut self, event: LearnerEvent<T>) {
  function process_valid (line 49) | fn process_valid(&mut self, event: LearnerEvent<V>) {
  function renderer (line 72) | fn renderer(self) -> Box<dyn crate::renderer::MetricsRenderer> {

FILE: crates/burn-train/src/metric/processor/mod.rs
  type ItemSync (line 35) | type ItemSync = f64;
  method sync (line 37) | fn sync(self) -> Self::ItemSync {
  function adapt (line 43) | fn adapt(&self) -> LossInput<B> {
  function process_train (line 49) | pub(crate) fn process_train(
  function end_epoch (line 73) | pub(crate) fn end_epoch(processor: &mut MinimalEventProcessor<f64, f64>,...

FILE: crates/burn-train/src/metric/processor/rl_metrics.rs
  type RLMetrics (line 10) | pub(crate) struct RLMetrics<TS: ItemLazy, ES: ItemLazy> {
  method default (line 27) | fn default() -> Self {
  function register_text_metric_agent (line 46) | pub(crate) fn register_text_metric_agent<Me: Metric + 'static>(&mut self...
  function register_agent_metric (line 56) | pub(crate) fn register_agent_metric<Me: Metric + Numeric + 'static>(&mut...
  function register_text_metric_train (line 66) | pub(crate) fn register_text_metric_train<Me: Metric + 'static>(&mut self...
  function register_metric_train (line 76) | pub(crate) fn register_metric_train<Me: Metric + Numeric + 'static>(&mut...
  function register_text_metric_agent_valid (line 86) | pub(crate) fn register_text_metric_agent_valid<Me: Metric + 'static>(&mu...
  function register_agent_metric_valid (line 96) | pub(crate) fn register_agent_metric_valid<Me: Metric + Numeric + 'static...
  function register_text_metric_episode (line 106) | pub(crate) fn register_text_metric_episode<Me: Metric + 'static>(&mut se...
  function register_episode_metric (line 116) | pub(crate) fn register_episode_metric<Me: Metric + Numeric + 'static>(&m...
  function register_text_metric_episode_valid (line 126) | pub(crate) fn register_text_metric_episode_valid<Me: Metric + 'static>(&...
  function register_episode_metric_valid (line 136) | pub(crate) fn register_episode_metric_valid<Me: Metric + Numeric + 'stat...
  function register_definition (line 147) | fn register_definition<Me: Metric>(&mut self, metric: &MetricWrapper<Me>) {
  function metric_definitions (line 155) | pub(crate) fn metric_definitions(&mut self) -> Vec<MetricDefinition> {
  function update_train_step (line 160) | pub(crate) fn update_train_step(
  function update_env_step (line 182) | pub(crate) fn update_env_step(
  function update_env_step_valid (line 204) | pub(crate) fn update_env_step_valid(
  function update_episode_end (line 226) | pub(crate) fn update_episode_end(
  function update_episode_end_valid (line 248) | pub(crate) fn update_episode_end_valid(

FILE: crates/burn-train/src/metric/processor/rl_processor.rs
  type RLEvent (line 10) | pub enum RLEvent<TS, ES> {
  type AgentEvaluationEvent (line 24) | pub enum AgentEvaluationEvent<T> {
  type RLEventProcessor (line 39) | pub struct RLEventProcessor<TS: ItemLazy, ES: ItemLazy> {
  function progress_indicators (line 46) | fn progress_indicators(&self, progress: &TrainingProgress) -> Vec<Progre...
  function progress_indicators_eval (line 55) | fn progress_indicators_eval(&self, progress: &TrainingProgress) -> Vec<P...
  function process_update_train (line 66) | fn process_update_train(&mut self, update: MetricsUpdate) {
  function process_update_valid (line 86) | fn process_update_valid(&mut self, update: MetricsUpdate) {
  function process_train (line 110) | fn process_train(&mut self, event: RLEvent<TS, ES>) {
  function process_valid (line 150) | fn process_valid(&mut self, event: AgentEvaluationEvent<ES>) {
  function renderer (line 174) | fn renderer(self) -> Box<dyn MetricsRenderer> {

FILE: crates/burn-train/src/metric/recall.rs
  type RecallMetric (line 18) | pub struct RecallMetric<B: Backend> {
  method default (line 26) | fn default() -> Self {
  function new (line 32) | fn new(config: ClassificationMetricConfig) -> Self {
  function binary (line 52) | pub fn binary(threshold: f64) -> Self {
  function multiclass (line 67) | pub fn multiclass(top_k: usize, class_reduction: ClassReduction) -> Self {
  function multilabel (line 83) | pub fn multilabel(threshold: f64, class_reduction: ClassReduction) -> Se...
  function class_average (line 90) | fn class_average(&self, mut aggregated_metric: Tensor<B, 1>) -> f64 {
  type Input (line 115) | type Input = ConfusionStatsInput<B>;
  method update (line 117) | fn update(&mut self, input: &Self::Input, _metadata: &MetricMetadata) ->...
  method clear (line 130) | fn clear(&mut self) {
  method name (line 134) | fn name(&self) -> MetricName {
  method attributes (line 138) | fn attributes(&self) -> MetricAttributes {
  method value (line 148) | fn value(&self) -> NumericEntry {
  method running_value (line 152) | fn running_value(&self) -> NumericEntry {
  function test_binary_recall (line 173) | fn test_binary_recall(#[case] threshold: f64, #[case] expected: f64) {
  function test_multiclass_recall (line 186) | fn test_multiclass_recall(
  function test_multilabel_recall (line 201) | fn test_multilabel_recall(
  function test_parameterized_unique_name (line 214) | fn test_parameterized_unique_name() {

FILE: crates/burn-train/src/metric/rl/cum_reward.rs
  type CumulativeRewardMetric (line 11) | pub struct CumulativeRewardMetric {
    method new (line 18) | pub fn new() -> Self {
  method default (line 27) | fn default() -> Self {
  type CumulativeRewardInput (line 34) | pub struct CumulativeRewardInput {
  type Input (line 39) | type Input = CumulativeRewardInput;
  method update (line 41) | fn update(
  method clear (line 53) | fn clear(&mut self) {
  method name (line 57) | fn name(&self) -> MetricName {
  method attributes (line 61) | fn attributes(&self) -> MetricAttributes {
  method value (line 71) | fn value(&self) -> NumericEntry {
  method running_value (line 75) | fn running_value(&self) -> NumericEntry {

FILE: crates/burn-train/src/metric/rl/ep_len.rs
  type EpisodeLengthMetric (line 11) | pub struct EpisodeLengthMetric {
    method new (line 18) | pub fn new() -> Self {
  method default (line 27) | fn default() -> Self {
  type EpisodeLengthInput (line 34) | pub struct EpisodeLengthInput {
  type Input (line 39) | type Input = EpisodeLengthInput;
  method update (line 41) | fn update(&mut self, item: &EpisodeLengthInput, _metadata: &MetricMetada...
  method clear (line 46) | fn clear(&mut self) {
  method name (line 50) | fn name(&self) -> MetricName {
  method attributes (line 54) | fn attributes(&self) -> MetricAttributes {
  method value (line 64) | fn value(&self) -> NumericEntry {
  method running_value (line 68) | fn running_value(&self) -> NumericEntry {

FILE: crates/burn-train/src/metric/rl/exploration_rate.rs
  type ExplorationRateMetric (line 11) | pub struct ExplorationRateMetric {
    method new (line 18) | pub fn new() -> Self {
  method default (line 27) | fn default() -> Self {
  type ExplorationRateInput (line 34) | pub struct ExplorationRateInput {
  type Input (line 39) | type Input = ExplorationRateInput;
  method update (line 41) | fn update(
  method clear (line 53) | fn clear(&mut self) {
  method name (line 57) | fn name(&self) -> MetricName {
  method attributes (line 61) | fn attributes(&self) -> MetricAttributes {
  method value (line 71) | fn value(&self) -> NumericEntry {
  method running_value (line 75) | fn running_value(&self) -> NumericEntry {

FILE: crates/burn-train/src/metric/state.rs
  type NumericMetricState (line 12) | pub struct NumericMetricState {
    method new (line 66) | pub fn new() -> Self {
    method reset (line 76) | pub fn reset(&mut self) {
    method update (line 84) | pub fn update(
    method current_value (line 124) | pub fn current_value(&self) -> NumericEntry {
    method running_value (line 132) | pub fn running_value(&self) -> NumericEntry {
  type FormatOptions (line 20) | pub struct FormatOptions {
    method new (line 28) | pub fn new(name: MetricName) -> Self {
    method unit (line 37) | pub fn unit(mut self, unit: &str) -> Self {
    method precision (line 43) | pub fn precision(mut self, precision: usize) -> Self {
    method name (line 49) | pub fn name(&self) -> &Arc<String> {
    method unit_value (line 54) | pub fn unit_value(&self) -> &Option<String> {
    method precision_value (line 59) | pub fn precision_value(&self) -> Option<usize> {
  method default (line 141) | fn default() -> Self {

FILE: crates/burn-train/src/metric/store/aggregate.rs
  type NumericMetricsAggregate (line 11) | pub(crate) struct NumericMetricsAggregate {
    method aggregate (line 24) | pub(crate) fn aggregate(
    method find_epoch (line 79) | pub(crate) fn find_epoch(
  type Key (line 16) | struct Key {
  type TestLogger (line 136) | struct TestLogger {
    method new (line 143) | fn new() -> Self {
    method log (line 149) | fn log(&mut self, num: f64) {
    method log_definition (line 158) | fn log_definition(&mut self) {
    method new_epoch (line 167) | fn new_epoch(&mut self) {
  constant NAME (line 140) | const NAME: &str = "test-logger";
  function should_find_epoch (line 173) | fn should_find_epoch() {
  function should_aggregate_numeric_entry (line 200) | fn should_aggregate_numeric_entry() {

FILE: crates/burn-train/src/metric/store/base.rs
  type Event (line 6) | pub enum Event {
  type NumericMetricUpdate (line 17) | pub struct NumericMetricUpdate {
  type MetricsUpdate (line 28) | pub struct MetricsUpdate {
  type EpochSummary (line 37) | pub struct EpochSummary {
  type EventStore (line 47) | pub trait EventStore: Send {
    method add_event (line 49) | fn add_event(&mut self, event: Event, split: Split);
    method find_epoch (line 52) | fn find_epoch(
    method find_metric (line 61) | fn find_metric(
  type Aggregate (line 72) | pub enum Aggregate {
  type Split (line 79) | pub enum Split {
    method fmt (line 89) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Direction (line 100) | pub enum Direction {

FILE: crates/burn-train/src/metric/store/client.rs
  type EventStoreClient (line 7) | pub struct EventStoreClient {
    method new (line 14) | pub(crate) fn new<C>(store: C) -> Self
    method add_event_train (line 30) | pub(crate) fn add_event_train(&self, event: Event) {
    method add_event_valid (line 37) | pub(crate) fn add_event_valid(&self, event: Event) {
    method add_event_test (line 44) | pub(crate) fn add_event_test(&self, event: Event, tag: Arc<String>) {
    method find_epoch (line 51) | pub fn find_epoch(
    method find_metric (line 76) | pub fn find_metric(
  type WorkerThread (line 102) | struct WorkerThread<S> {
  function run (line 111) | fn run(mut self) {
  type Message (line 139) | enum Message {
  method drop (line 161) | fn drop(&mut self) {

FILE: crates/burn-train/src/metric/store/log.rs
  type LogEventStore (line 7) | pub(crate) struct LogEventStore {
    method register_logger (line 64) | pub(crate) fn register_logger<ML: MetricLogger + 'static>(&mut self, l...
    method has_loggers (line 69) | pub(crate) fn has_loggers(&self) -> bool {
  method add_event (line 14) | fn add_event(&mut self, event: Event, split: Split) {
  method find_epoch (line 39) | fn find_epoch(
  method find_metric (line 50) | fn find_metric(

FILE: crates/burn-train/src/metric/top_k_acc.rs
  type TopKAccuracyMetric (line 16) | pub struct TopKAccuracyMetric<B: Backend> {
  type TopKAccuracyInput (line 28) | pub struct TopKAccuracyInput<B: Backend> {
  function new (line 37) | pub fn new(k: usize) -> Self {
  function with_pad_token (line 46) | pub fn with_pad_token(mut self, index: usize) -> Self {
  type Input (line 53) | type Input = TopKAccuracyInput<B>;
  method update (line 55) | fn update(
  method clear (line 99) | fn clear(&mut self) {
  method name (line 103) | fn name(&self) -> MetricName {
  method attributes (line 107) | fn attributes(&self) -> MetricAttributes {
  method value (line 117) | fn value(&self) -> NumericEntry {
  method running_value (line 121) | fn running_value(&self) -> NumericEntry {
  function test_accuracy_without_padding (line 132) | fn test_accuracy_without_padding() {
  function test_accuracy_with_padding (line 153) | fn test_accuracy_with_padding() {
  function test_parameterized_unique_name (line 177) | fn test_parameterized_unique_name() {

FILE: crates/burn-train/src/metric/vision/dice.rs
  type DiceInput (line 18) | pub struct DiceInput<B: Backend, const D: usize = 4> {
  function new (line 47) | pub fn new(outputs: Tensor<B, D, Int>, targets: Tensor<B, D, Int>) -> Se...
  type DiceMetricConfig (line 61) | pub struct DiceMetricConfig {
  method default (line 71) | fn default() -> Self {
  type DiceMetric (line 88) | pub struct DiceMetric<B: Backend, const D: usize = 4> {
  function new (line 100) | pub fn new() -> Self {
  function with_config (line 105) | pub fn with_config(config: DiceMetricConfig) -> Self {
  type Input (line 117) | type Input = DiceInput<B, D>;
  method name (line 119) | fn name(&self) -> MetricName {
  method update (line 123) | fn update(&mut self, item: &Self::Input, _metadata: &MetricMetadata) -> ...
  method clear (line 171) | fn clear(&mut self) {
  method attributes (line 175) | fn attributes(&self) -> MetricAttributes {
  function value (line 185) | fn value(&self) -> crate::metric::NumericEntry {
  function running_value (line 189) | fn running_value(&self) -> crate::metric::NumericEntry {
  function test_dice_perfect_overlap (line 201) | fn test_dice_perfect_overlap() {
  function test_dice_no_overlap (line 213) | fn test_dice_no_overlap() {
  function test_dice_partial_overlap (line 225) | fn test_dice_partial_overlap() {
  function test_dice_empty_masks (line 238) | fn test_dice_empty_masks() {
  function test_dice_no_background (line 250) | fn test_dice_no_background() {
  function test_dice_with_background (line 262) | fn test_dice_with_background() {
  function test_dice_ignored_background (line 278) | fn test_dice_ignored_background() {
  function test_invalid_input_dimensions (line 295) | fn test_invalid_input_dimensions() {
  function test_mismatched_shape (line 308) | fn test_mismatched_shape() {
  function test_include_background_panic (line 319) | fn test_include_background_panic() {

FILE: crates/burn-train/src/metric/vision/dists/l2pool.rs
  type L2Pool2dConfig (line 16) | pub struct L2Pool2dConfig {
    method new (line 38) | pub fn new(kernel_size: usize, stride: usize, padding: usize) -> Self {
    method init (line 47) | pub fn init<B: Backend>(&self, channels: usize, device: &B::Device) ->...
  method default (line 26) | fn default() -> Self {
  type L2Pool2d (line 63) | pub struct L2Pool2d<B: Backend> {
  function new (line 70) | pub fn new(
  function create_hanning_kernel (line 98) | fn create_hanning_kernel<B2: Backend>(
  function forward (line 153) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {

FILE: crates/burn-train/src/metric/vision/dists/metric.rs
  constant CHANNELS (line 20) | const CHANNELS: [usize; 6] = [3, 64, 128, 256, 512, 512];
  constant C1 (line 23) | const C1: f32 = 1e-6;
  constant C2 (line 26) | const C2: f32 = 1e-6;
  constant IMAGENET_MEAN (line 29) | const IMAGENET_MEAN: [f32; 3] = [0.485, 0.456, 0.406];
  constant IMAGENET_STD (line 30) | const IMAGENET_STD: [f32; 3] = [0.229, 0.224, 0.225];
  type Normalizer (line 37) | pub struct Normalizer<B: Backend> {
  function imagenet (line 46) | pub fn imagenet(device: &B::Device) -> Self {
  function normalize (line 68) | pub fn normalize(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  type DistsConfig (line 75) | pub struct DistsConfig {
    method init (line 83) | pub fn init<B: Backend>(&self, device: &B::Device) -> Dists<B> {
    method init_pretrained (line 105) | pub fn init_pretrained<B: Backend>(&self, device: &B::Device) -> Dists...
  type Dists (line 132) | pub struct Dists<B: Backend> {
  method custom_settings (line 144) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 150) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 170) | pub fn forward(
  function forward_no_reduction (line 194) | pub fn forward_no_reduction(&self, input: Tensor<B, 4>, target: Tensor<B...
  function compute_stage_similarity (line 252) | fn compute_stage_similarity(
  function preprocess (line 335) | fn preprocess(
  type TestBackend (line 361) | type TestBackend = NdArray<f32>;
  type FT (line 362) | type FT = FloatElem<TestBackend>;
  type TestTensor (line 363) | type TestTensor<const D: usize> = Tensor<TestBackend, D>;
  function test_dists_identical_images_zero_distance (line 366) | fn test_dists_identical_images_zero_distance() {
  function test_dists_different_images_nonzero_distance (line 385) | fn test_dists_different_images_nonzero_distance() {
  function test_dists_symmetry (line 402) | fn test_dists_symmetry() {
  function test_dists_batch_processing (line 418) | fn test_dists_batch_processing() {
  function test_dists_no_reduction (line 431) | fn test_dists_no_reduction() {
  function display_dists (line 445) | fn display_dists() {
  function test_dists_pretrained (line 460) | fn test_dists_pretrained() {

FILE: crates/burn-train/src/metric/vision/dists/vgg16_l2pool.rs
  type Vgg16L2PoolExtractor (line 24) | pub struct Vgg16L2PoolExtractor<B: Backend> {
  function new (line 55) | pub fn new(device: &B::Device) -> Self {
  function forward (line 129) | pub fn forward(&self, x: Tensor<B, 4>) -> Vec<Tensor<B, 4>> {

FILE: crates/burn-train/src/metric/vision/dists/weights.rs
  constant DISTS_WEIGHTS_URL (line 16) | const DISTS_WEIGHTS_URL: &str =
  constant VGG16_IMAGENET_URL (line 20) | const VGG16_IMAGENET_URL: &str = "https://download.pytorch.org/models/vg...
  function get_cache_dir (line 23) | fn get_cache_dir() -> PathBuf {
  function download_if_needed (line 37) | fn download_if_needed(url: &str, cache_path: &PathBuf, message: &str) {
  function load_pretrained_weights (line 60) | pub fn load_pretrained_weights<B: Backend>(mut dists: Dists<B>) -> Dists...
  function load_vgg16_backbone_weights (line 89) | fn load_vgg16_backbone_weights<B: Backend>(mut dists: Dists<B>, cache_pa...
  function load_dists_weights (line 117) | fn load_dists_weights<B: Backend>(mut dists: Dists<B>, cache_path: &Path...

FILE: crates/burn-train/src/metric/vision/lpips/alexnet.rs
  type AlexFeatureExtractor (line 21) | pub struct AlexFeatureExtractor<B: Backend> {
  function new (line 36) | pub fn new(device: &B::Device) -> Self {
  function forward (line 68) | pub fn forward(&self, x: Tensor<B, 4>) -> Vec<Tensor<B, 4>> {
  function max_pool2d_alex (line 98) | fn max_pool2d_alex<B: Backend>(x: Tensor<B, 4>) -> Tensor<B, 4> {

FILE: crates/burn-train/src/metric/vision/lpips/metric.rs
  type LpipsNet (line 24) | pub enum LpipsNet {
  type LpipsConfig (line 54) | pub struct LpipsConfig {
    method init_pretrained (line 88) | pub fn init_pretrained<B: Backend>(&self, device: &B::Device) -> Lpips...
    method init (line 102) | pub fn init<B: Backend>(&self, device: &B::Device) -> Lpips<B> {
  type Lpips (line 202) | pub enum Lpips<B: Backend> {
  type LpipsVgg (line 213) | pub struct LpipsVgg<B: Backend> {
  type LpipsAlex (line 228) | pub struct LpipsAlex<B: Backend> {
  type LpipsSqueeze (line 243) | pub struct LpipsSqueeze<B: Backend> {
  function forward_no_reduction (line 260) | pub fn forward_no_reduction(&self, input: Tensor<B, 4>, target: Tensor<B...
  function forward_no_reduction (line 285) | pub fn forward_no_reduction(&self, input: Tensor<B, 4>, target: Tensor<B...
  function forward_no_reduction (line 310) | pub fn forward_no_reduction(&self, input: Tensor<B, 4>, target: Tensor<B...
  method custom_settings (line 336) | fn custom_settings(&self) -> Option<DisplaySettings> {
  method custom_content (line 342) | fn custom_content(&self, content: Content) -> Option<Content> {
  function forward (line 373) | pub fn forward(
  function forward_no_reduction (line 403) | pub fn forward_no_reduction(&self, input: Tensor<B, 4>, target: Tensor<B...
  function normalize_tensor (line 417) | fn normalize_tensor<B: Backend>(x: Tensor<B, 4>) -> Tensor<B, 4> {
  function scaling_layer (line 425) | fn scaling_layer<B: Backend>(x: Tensor<B, 4>) -> Tensor<B, 4> {
  function compute_layer_distance (line 441) | fn compute_layer_distance<B: Backend>(
  function preprocess_inputs (line 470) | fn preprocess_inputs<B: Backend>(
  type TestBackend (line 499) | type TestBackend = NdArray<f32>;
  type FT (line 500) | type FT = FloatElem<TestBackend>;
  type TestTensor (line 501) | type TestTensor<const D: usize> = Tensor<TestBackend, D>;
  function test_lpips_identical_images_zero_distance (line 509) | fn test_lpips_identical_images_zero_distance() {
  function test_lpips_different_images_nonzero_distance (line 527) | fn test_lpips_different_images_nonzero_distance() {
  function test_lpips_symmetry (line 545) | fn test_lpips_symmetry() {
  function test_lpips_forward_mean_reduction (line 565) | fn test_lpips_forward_mean_reduction() {
  function test_lpips_forward_no_reduction (line 578) | fn test_lpips_forward_no_reduction() {
  function test_lpips_alex_identical_images_zero_distance (line 597) | fn test_lpips_alex_identical_images_zero_distance() {
  function test_lpips_alex_different_images_nonzero_distance (line 612) | fn test_lpips_alex_different_images_nonzero_distance() {
  function test_lpips_squeeze_identical_images_zero_distance (line 636) | fn test_lpips_squeeze_identical_images_zero_distance() {
  function test_lpips_squeeze_different_images_nonzero_distance (line 652) | fn test_lpips_squeeze_different_images_nonzero_distance() {
  function display_vgg (line 676) | fn display_vgg() {
  function display_alex (line 686) | fn display_alex() {
  function display_squeeze (line 696) | fn display_squeeze() {
  function test_lpips_pretrained_vgg (line 712) | fn test_lpips_pretrained_vgg() {
  function test_lpips_pretrained_alex (line 744) | fn test_lpips_pretrained_alex() {
  function test_lpips_pretrained_squeeze (line 774) | fn test_lpips_pretrained_squeeze() {

FILE: crates/burn-train/src/metric/vision/lpips/squeezenet.rs
  type FireModule (line 18) | pub struct FireModule<B: Backend> {
  function new (line 29) | pub fn new(
  function forward (line 51) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
  type SqueezeFeatureExtractor (line 71) | pub struct SqueezeFeatureExtractor<B: Backend> {
  function new (line 94) | pub fn new(device: &B::Device) -> Self {
  function forward (line 114) | pub fn forward(&self, x: Tensor<B, 4>) -> Vec<Tensor<B, 4>> {
  function max_pool2d_squeeze (line 155) | fn max_pool2d_squeeze<B: Backend>(x: Tensor<B, 4>) -> Tensor<B, 4> {

FILE: crates/burn-train/src/metric/vision/lpips/vgg.rs
  type VggFeatureExtractor (line 21) | pub struct VggFeatureExtractor<B: Backend> {
  function new (line 44) | pub fn new(device: &B::Device) -> Self {
  function forward (line 74) | pub fn forward(&self, x: Tensor<B, 4>) -> Vec<Tensor<B, 4>> {
  function max_pool2d (line 114) | fn max_pool2d<B: Backend>(x: Tensor<B, 4>) -> Tensor<B, 4> {

FILE: crates/burn-train/src/metric/vision/lpips/weights.rs
  constant LPIPS_VGG_URL (line 16) | const LPIPS_VGG_URL: &str =
  constant LPIPS_ALEX_URL (line 18) | const LPIPS_ALEX_URL: &str =
  constant LPIPS_SQUEEZE_URL (line 20) | const LPIPS_SQUEEZE_URL: &str =
  constant VGG16_IMAGENET_URL (line 24) | const VGG16_IMAGENET_URL: &str = "https://download.pytorch.org/models/vg...
  constant ALEXNET_IMAGENET_URL (line 25) | const ALEXNET_IMAGENET_URL: &str = "https://download.pytorch.org/models/...
  constant SQUEEZENET_IMAGENET_URL (line 26) | const SQUEEZENET_IMAGENET_URL: &str =
  function get_lpips_weights_url (line 30) | pub fn get_lpips_weights_url(net: LpipsNet) -> &'static str {
  function get_backbone_weights_url (line 39) | pub fn get_backbone_weights_url(net: LpipsNet) -> &'static str {
  function get_cache_dir (line 48) | fn get_cache_dir() -> PathBuf {
  function download_if_needed (line 62) | fn download_if_needed(url: &str, cache_path: &PathBuf, message: &str) {
  function load_pretrained_weights (line 86) | pub fn load_pretrained_weights<B: Backend>(mut lpips: Lpips<B>, net: Lpi...
  function load_backbone_weights (line 119) | fn load_backbone_weights<B: Backend>(lpips: Lpips<B>, cache_path: &PathB...
  function load_lpips_weights (line 183) | fn load_lpips_weights<B: Backend>(lpips: Lpips<B>, cache_path: &PathBuf)...

FILE: crates/burn-train/src/metric/vision/ms_ssim.rs
  type MsSsimInput (line 37) | pub struct MsSsimInput<B: Backend> {
  function new (line 56) | pub fn new(outputs: Tensor<B, 4>, targets: Tensor<B, 4>) -> Self {
  type MsSsimMetricConfig (line 69) | pub struct MsSsimMetricConfig {
    method new (line 126) | pub fn new(pixel_range: f32) -> Self {
    method with_k1_k2 (line 148) | pub fn with_k1_k2(mut self, k1: f32, k2: f32) -> Self {
    method with_kernel_size (line 164) | pub fn with_kernel_size(mut self, kernel_size: usize) -> Self {
    method with_sigma (line 180) | pub fn with_sigma(mut self, sigma: f32) -> Self {
    method with_channels (line 196) | pub fn with_channels(mut self, channels: usize) -> Self {
    method with_betas (line 214) | pub fn with_betas(mut self, betas: Vec<f32>) -> Self {
  type MsSsimMetric (line 270) | pub struct MsSsimMetric<B: Backend> {
  function new (line 301) | pub fn new(config: MsSsimMetricConfig, device: &B::Device) -> Self {
  function with_name (line 336) | pub fn with_name(mut self, name: &str) -> Self {
  function create_1d_gaussian_kernel (line 342) | fn create_1d_gaussian_kernel(config: &MsSsimMetricConfig, device: &B::De...
  function gaussian_separable_conv (line 365) | fn gaussian_separable_conv(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
  type Input (line 383) | type Input = MsSsimInput<B>;
  method name (line 385) | fn name(&self) -> MetricName {
  method update (line 389) | fn update(&mut self, item: &Self::Input, _metadata: &MetricMetadata) -> ...
  method clear (line 487) | fn clear(&mut self) {
  method attributes (line 491) | fn attributes(&self) -> MetricAttributes {
  method value (line 501) | fn value(&self) -> NumericEntry {
  method running_value (line 505) | fn running_value(&self) -> NumericEntry {
  function test_config (line 516) | fn test_config() -> MsSsimMetricConfig {
  function test_ms_ssim_perfect_similarity (line 526) | fn test_ms_ssim_perfect_similarity() {
  function test_ms_ssim_completely_different (line 550) | fn test_ms_ssim_completely_different() {
  function test_ms_ssim_similar_images (line 569) | fn test_ms_ssim_similar_images() {
  function test_ms_ssim_batch_averaging (line 588) | fn test_ms_ssim_batch_averaging() {
  function test_ms_ssim_multichannel (line 620) | fn test_ms_ssim_multichannel() {
  function test_ms_ssim_running_average (line 648) | fn test_ms_ssim_running_average() {
  function test_ms_ssim_single_scale_small_image (line 677) | fn test_ms_ssim_single_scale_small_image() {
  function test_ssim_symmetry (line 707) | fn test_ssim_symmetry() {
  function test_ms_ssim_clear (line 746) | fn test_ms_ssim_clear() {
  function test_ms_ssim_custom_name (line 761) | fn test_ms_ssim_custom_name() {
  function test_ms_ssim_default_name (line 769) | fn test_ms_ssim_default_name() {
  function test_ms_ssim_attributes (line 777) | fn test_ms_ssim_attributes() {
  function test_ms_ssim_shape_mismatch (line 793) | fn test_ms_ssim_shape_mismatch() {
  function test_ms_ssim_negative_k1 (line 802) | fn test_ms_ssim_negative_k1() {
  function test_ms_ssim_negative_k2 (line 808) | fn test_ms_ssim_negative_k2() {
  function test_ms_ssim_negative_data_range (line 814) | fn test_ms_ssim_negative_data_range() {
  function test_ms_ssim_zero_data_range (line 820) | fn test_ms_ssim_zero_data_range() {
  function test_ms_ssim_even_kernel_size (line 826) | fn test_ms_ssim_even_kernel_size() {
  function test_ms_ssim_zero_kernel_size (line 832) | fn test_ms_ssim_zero_kernel_size() {
  function test_ms_ssim_negative_sigma (line 838) | fn test_ms_ssim_negative_sigma() {
  function test_ms_ssim_zero_sigma (line 844) | fn test_ms_ssim_zero_sigma() {
  function test_ms_ssim_zero_channels (line 850) | fn test_ms_ssim_zero_channels() {
  function test_ms_ssim_empty_betas (line 856) | fn test_ms_ssim_empty_betas() {
  function test_ms_ssim_negative_betas (line 862) | fn test_ms_ssim_negative_betas() {
  function test_ms_ssim_image_too_small (line 868) | fn test_ms_ssim_image_too_small() {

FILE: crates/burn-train/src/metric/vision/psnr.rs
  type PsnrInput (line 20) | pub struct PsnrInput<B: Backend> {
  function new (line 43) | pub fn new(outputs: Tensor<B, 4>, targets: Tensor<B, 4>) -> Self {
  type PsnrMetricConfig (line 56) | pub struct PsnrMetricConfig {
    method new (line 83) | pub fn new(max_pixel_val: f64) -> Self {
    method with_epsilon (line 92) | pub fn with_epsilon(mut self, epsilon: f64) -> Self {
  type PsnrMetric (line 115) | pub struct PsnrMetric<B: Backend> {
  function new (line 133) | pub fn new(config: PsnrMetricConfig) -> Self {
  function with_name (line 149) | pub fn with_name(mut self, name: &str) -> Self {
  type Input (line 156) | type Input = PsnrInput<B>;
  method name (line 158) | fn name(&self) -> MetricName {
  method update (line 162) | fn update(&mut self, item: &Self::Input, _metadata: &MetricMetadata) -> ...
  method clear (line 197) | fn clear(&mut self) {
  method attributes (line 201) | fn attributes(&self) -> MetricAttributes {
  method value (line 211) | fn value(&self) -> NumericEntry {
  method running_value (line 215) | fn running_value(&self) -> NumericEntry {
  function test_psnr_perfect_reconstruction (line 227) | fn test_psnr_perfect_reconstruction() {
  function test_psnr_constant_error (line 253) | fn test_psnr_constant_error() {
  function test_psnr_varying_error (line 280) | fn test_psnr_varying_error() {
  function test_psnr_max_pixel_255 (line 309) | fn test_psnr_max_pixel_255() {
  function test_psnr_batch_averaging (line 339) | fn test_psnr_batch_averaging() {
  function test_psnr_multichannel (line 376) | fn test_psnr_multichannel() {
  function test_psnr_running_average (line 406) | fn test_psnr_running_average() {
  function test_psnr_clear (line 451) | fn test_psnr_clear() {
  function test_psnr_custom_name (line 481) | fn test_psnr_custom_name() {
  function test_psnr_custom_epsilon (line 489) | fn test_psnr_custom_epsilon() {
  function test_psnr_negative_errors (line 515) | fn test_psnr_negative_errors() {
  function test_psnr_large_batch (line 544) | fn test_psnr_large_batch() {
  function test_psnr_attributes (line 569) | fn test_psnr_attributes() {
  function test_psnr_shape_mismatch (line 585) | fn test_psnr_shape_mismatch() {
  function test_psnr_negative_max_pixel_val (line 595) | fn test_psnr_negative_max_pixel_val() {
  function test_psnr_zero_max_pixel_val (line 601) | fn test_psnr_zero_max_pixel_val() {
  function test_psnr_negative_epsilon (line 607) | fn test_psnr_negative_epsilon() {
  function test_psnr_zero_epsilon (line 613) | fn test_psnr_zero_epsilon() {

FILE: crates/burn-train/src/metric/vision/ssim.rs
  type SsimInput (line 19) | pub struct SsimInput<B: Backend> {
  function new (line 42) | pub fn new(outputs: Tensor<B, 4>, targets: Tensor<B, 4>) -> Self {
  type SsimMetricConfig (line 55) | pub struct SsimMetricConfig {
    method new (line 105) | pub fn new(pixel_range: f32) -> Self {
    method with_k1_k2 (line 125) | pub fn with_k1_k2(mut self, k1: f32, k2: f32) -> Self {
    method with_kernel_size (line 141) | pub fn with_kernel_size(mut self, kernel_size: usize) -> Self {
    method with_sigma (line 157) | pub fn with_sigma(mut self, sigma: f32) -> Self {
  type SsimMetric (line 181) | pub struct SsimMetric<B: Backend> {
  function new (line 205) | pub fn new(config: SsimMetricConfig) -> Self {
  function with_name (line 218) | pub fn with_name(mut self, name: &str) -> Self {
  function create_1d_gaussian_kernel (line 228) | fn create_1d_gaussian_kernel(&self) -> Vec<f32> {
  function gaussian_conv_separable (line 257) | fn gaussian_conv_separable(
  type Input (line 293) | type Input = SsimInput<B>;
  method name (line 295) | fn name(&self) -> MetricName {
  method update (line 299) | fn update(&mut self, item: &Self::Input, _metadata: &MetricMetadata) -> ...
  method clear (line 365) | fn clear(&mut self) {
  method attributes (line 369) | fn attributes(&self) -> MetricAttributes {
  method value (line 379) | fn value(&self) -> NumericEntry {
  method running_value (line 383) | fn running_value(&self) -> NumericEntry {
  function test_config (line 395) | fn test_config() -> SsimMetricConfig {
  function test_ssim_perfect_similarity (line 402) | fn test_ssim_perfect_similarity() {
  function test_ssim_completely_different (line 429) | fn test_ssim_completely_different() {
  function test_ssim_similar_images (line 450) | fn test_ssim_similar_images() {
  function test_ssim_batch_averaging (line 469) | fn test_ssim_batch_averaging() {
  function test_ssim_multichannel (line 523) | fn test_ssim_multichannel() {
  function test_ssim_symmetry (line 564) | fn test_ssim_symmetry() {
  function test_ssim_range (line 608) | fn test_ssim_range() {
  function test_ssim_running_average (line 629) | fn test_ssim_running_average() {
  function test_ssim_clear (line 670) | fn test_ssim_clear() {
  function test_ssim_custom_name (line 701) | fn test_ssim_custom_name() {
  function test_ssim_pixel_range_255 (line 715) | fn test_ssim_pixel_range_255() {
  function test_ssim_large_batch (line 737) | fn test_ssim_large_batch() {
  function test_ssim_default_kernel_size (line 757) | fn test_ssim_default_kernel_size() {
  function test_ssim_attributes (line 779) | fn test_ssim_attributes() {
  function test_ssim_shape_mismatch (line 795) | fn test_ssim_shape_mismatch() {
  function test_ssim_image_too_small (line 805) | fn test_ssim_image_too_small() {
  function test_ssim_valid_k1_k2 (line 818) | fn test_ssim_valid_k1_k2() {
  function test_ssim_negative_pixel_range (line 830) | fn test_ssim_negative_pixel_range() {
  function test_ssim_zero_pixel_range (line 836) | fn test_ssim_zero_pixel_range() {
  function test_ssim_negative_k1 (line 842) | fn test_ssim_negative_k1() {
  function test_ssim_negative_k2 (line 848) | fn test_ssim_negative_k2() {
  function test_ssim_even_kernel_size (line 854) | fn test_ssim_even_kernel_size() {
  function test_ssim_zero_kernel_size (line 860) | fn test_ssim_zero_kernel_size() {
  function test_ssim_negative_sigma (line 866) | fn test_ssim_negative_sigma() {
  function test_ssim_zero_sigma (line 872) | fn test_ssim_zero_sigma() {

FILE: crates/burn-train/src/metric/wer.rs
  type WordErrorRate (line 18) | pub struct WordErrorRate<B: Backend> {
  type WerInput (line 27) | pub struct WerInput<B: Backend> {
  method default (line 34) | fn default() -> Self {
  function new (line 41) | pub fn new() -> Self {
  function with_pad_token (line 51) | pub fn with_pad_token(mut self, index: usize) -> Self {
  type Input (line 58) | type Input = WerInput<B>;
  method update (line 60) | fn update(&mut self, input: &WerInput<B>, _metadata: &MetricMetadata) ->...
  method name (line 125) | fn name(&self) -> MetricName {
  method clear (line 129) | fn clear(&mut self) {
  method attributes (line 133) | fn attributes(&self) -> MetricAttributes {
  method value (line 143) | fn value(&self) -> NumericEntry {
  method running_value (line 147) | fn running_value(&self) -> NumericEntry {
  function test_wer_without_padding (line 159) | fn test_wer_without_padding() {
  function test_wer_without_padding_two_errors (line 174) | fn test_wer_without_padding_two_errors() {
  function test_wer_with_padding (line 192) | fn test_wer_with_padding() {
  function test_clear_resets_state (line 209) | fn test_clear_resets_state() {

FILE: crates/burn-train/src/renderer/base.rs
  type MetricsRendererTraining (line 10) | pub trait MetricsRendererTraining: Send + Sync {
    method update_train (line 16) | fn update_train(&mut self, state: MetricState);
    method update_valid (line 23) | fn update_valid(&mut self, state: MetricState);
    method render_train (line 30) | fn render_train(&mut self, item: TrainingProgress, progress_indicators...
    method render_valid (line 37) | fn render_valid(&mut self, item: TrainingProgress, progress_indicators...
    method on_train_end (line 45) | fn on_train_end(
  type MetricsRenderer (line 55) | pub trait MetricsRenderer: MetricsRendererEvaluation + MetricsRendererTr...
    method manual_close (line 57) | fn manual_close(&mut self);
    method register_metric (line 59) | fn register_metric(&mut self, definition: MetricDefinition);
  type EvaluationName (line 66) | pub struct EvaluationName {
    method new (line 72) | pub fn new<S: core::fmt::Display>(s: S) -> Self {
    method as_str (line 79) | pub fn as_str(&self) -> &str {
    method fmt (line 85) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type MetricsRendererEvaluation (line 91) | pub trait MetricsRendererEvaluation: Send + Sync {
    method update_test (line 97) | fn update_test(&mut self, name: EvaluationName, state: MetricState);
    method render_test (line 103) | fn render_test(&mut self, item: EvaluationProgress, progress_indicator...
    method on_test_end (line 111) | fn on_test_end(
  type MetricState (line 122) | pub enum MetricState {
  type TrainingProgress (line 131) | pub struct TrainingProgress {
    method from (line 153) | fn from(value: &EvaluationProgress) -> Self {
    method none (line 164) | pub fn none() -> Self {
  type EvaluationProgress (line 144) | pub struct EvaluationProgress {
  type ProgressType (line 177) | pub enum ProgressType {
  function default_summary_action (line 194) | fn default_summary_action(summary: Option<LearnerSummary>) {

FILE: crates/burn-train/src/renderer/cli.rs
  type CliMetricsRenderer (line 7) | pub struct CliMetricsRenderer;
    method new (line 12) | pub fn new() -> Self {
  method update_train (line 18) | fn update_train(&mut self, _state: MetricState) {}
  method update_valid (line 20) | fn update_valid(&mut self, _state: MetricState) {}
  method render_train (line 22) | fn render_train(&mut self, item: TrainingProgress, _progress_indicators:...
  method render_valid (line 26) | fn render_valid(&mut self, item: TrainingProgress, _progress_indicators:...
  method render_test (line 32) | fn render_test(&mut self, item: EvaluationProgress, _progress_indicators...
  method update_test (line 36) | fn update_test(&mut self, _name: super::EvaluationName, _state: MetricSt...
  method manual_close (line 40) | fn manual_close(&mut self) {
  method register_metric (line 44) | fn register_metric(&mut self, _definition: crate::metric::MetricDefiniti...

FILE: crates/burn-train/src/renderer/mod.rs
  function default_renderer (line 24) | pub(crate) fn default_renderer(

FILE: crates/burn-train/src/renderer/tui/base.rs
  type MetricsView (line 12) | pub(crate) struct MetricsView<'a> {
  function render (line 21) | pub(crate) fn render(self, frame: &mut TerminalFrame<'_>, size: Rect) {
  type TuiSplit (line 53) | pub(crate) enum TuiSplit {
    method fmt (line 89) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method color (line 99) | pub(crate) fn color(&self) -> Color {
  type TuiGroup (line 60) | pub(crate) enum TuiGroup {
    method fmt (line 80) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type TuiTag (line 66) | pub(crate) struct TuiTag {
    method fmt (line 72) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: crates/burn-train/src/renderer/tui/controls.rs
  type ControlsView (line 10) | pub(crate) struct ControlsView;
    method render (line 14) | pub(crate) fn render(self, frame: &mut TerminalFrame<'_>, size: Rect) {

FILE: crates/burn-train/src/renderer/tui/full_history.rs
  type FullHistoryPlot (line 14) | pub(crate) struct FullHistoryPlot {
    method new (line 36) | pub(crate) fn new(max_samples: usize) -> Self {
    method update_max_sample (line 50) | pub(crate) fn update_max_sample(&mut self, split: TuiSplit, ratio: f64) {
    method push (line 62) | pub(crate) fn push(&mut self, tag: TuiTag, data: NumericEntry) {
    method datasets (line 83) | pub(crate) fn datasets(&self) -> Vec<Dataset<'_>> {
    method bars (line 93) | pub(crate) fn bars(&self, max: u64, bar_width: &mut usize) -> Vec<Bar<...
    method next_x (line 106) | fn next_x(&mut self) -> f64 {
    method update_bounds (line 112) | fn update_bounds(&mut self) {
  type FullHistoryPoints (line 22) | struct FullHistoryPoints {
    method new (line 128) | fn new(max_samples: usize) -> Self {
    method push (line 142) | fn push(&mut self, (x, y): (f64, NumericEntry)) {
    method resize (line 186) | fn resize(&mut self) {
    method dataset (line 221) | fn dataset<'a>(&'a self, name: String, color: Color) -> Dataset<'a> {
    method bar (line 230) | fn bar<'a>(&'a self, tag: &TuiTag, max: u64) -> Option<(Bar<'a>, usize...
  function test_points (line 259) | fn test_points() {

FILE: crates/burn-train/src/renderer/tui/metric_numeric.rs
  constant MAX_NUM_SAMPLES_RECENT (line 19) | const MAX_NUM_SAMPLES_RECENT: usize = 1000;
  constant MAX_NUM_SAMPLES_FULL (line 22) | const MAX_NUM_SAMPLES_FULL: usize = 250;
  type NumericMetricsState (line 26) | pub(crate) struct NumericMetricsState {
    method push (line 50) | pub(crate) fn push(&mut self, tag: TuiTag, name: MetricName, data: Num...
    method update_progress_train (line 67) | pub(crate) fn update_progress_train(&mut self, progress: &TrainingProg...
    method update_progress_valid (line 79) | pub(crate) fn update_progress_valid(&mut self, progress: &TrainingProg...
    method update_progress_test (line 101) | pub(crate) fn update_progress_test(&mut self, progress: &EvaluationPro...
    method view (line 117) | pub(crate) fn view(&self) -> NumericMetricView<'_> {
    method on_event (line 135) | pub(crate) fn on_event(&mut self, event: &Event) {
    method switch_kind (line 154) | fn switch_kind(&mut self) {
    method next_metric (line 162) | fn next_metric(&mut self) {
    method previous_metric (line 169) | fn previous_metric(&mut self) {
    method line_chart (line 180) | fn line_chart<'a>(&'a self) -> Chart<'a> {
    method bar_chart (line 208) | fn bar_chart<'a>(&'a self) -> BarChart<'a> {
  type PlotKind (line 39) | pub(crate) enum PlotKind {
  type NumericMetricView (line 225) | pub(crate) enum NumericMetricView<'a> {
  function render (line 232) | pub(crate) fn render(self, frame: &mut TerminalFrame<'_>, size: Rect) {

FILE: crates/burn-train/src/renderer/tui/metric_text.rs
  type TextMetricsState (line 15) | pub(crate) struct TextMetricsState {
    method update (line 59) | pub(crate) fn update(
    method view (line 77) | pub(crate) fn view(&self) -> TextMetricView {
  type MetricGroup (line 20) | struct MetricGroup {
    method new (line 25) | fn new(group: TuiGroup, metric: MetricSplits) -> Self {
    method update (line 30) | fn update(&mut self, split: TuiSplit, group: TuiGroup, metric: MetricE...
  type MetricSplits (line 42) | struct MetricSplits {
    method new (line 47) | fn new(split: TuiSplit, metric: MetricEntry) -> Self {
    method update (line 53) | fn update(&mut self, split: TuiSplit, metric: MetricEntry) {
  type TextMetricView (line 82) | pub(crate) struct TextMetricView {
    method new (line 87) | fn new(names: &[MetricName], data: &BTreeMap<String, MetricGroup>) -> ...
    method render (line 115) | pub(crate) fn render(self, frame: &mut TerminalFrame<'_>, size: Rect) {

FILE: crates/burn-train/src/renderer/tui/plot_utils.rs
  constant AXIS_TITLE_PRECISION (line 3) | const AXIS_TITLE_PRECISION: usize = 2;
  type PlotAxes (line 6) | pub(crate) struct PlotAxes {
    method update_bounds (line 26) | pub(crate) fn update_bounds(&mut self, (x_min, x_max): (f64, f64), (y_...
  method default (line 14) | fn default() -> Self {

FILE: crates/burn-train/src/renderer/tui/popup.rs
  type CallbackFn (line 12) | pub(crate) trait CallbackFn: Send + Sync {
    method call (line 14) | fn call(&self) -> bool;
  type Callback (line 18) | pub(crate) struct Callback {
    method new (line 27) | pub(crate) fn new<T, D, C>(title: T, description: D, trigger: char, ca...
  type PopupState (line 43) | pub(crate) enum PopupState {
    method is_empty (line 50) | pub(crate) fn is_empty(&self) -> bool {
    method on_event (line 54) | pub(crate) fn on_event(&mut self, event: &Event) {
    method view (line 77) | pub(crate) fn view(&self) -> Option<PopupView<'_>> {
  type PopupView (line 86) | pub(crate) struct PopupView<'a> {
  function render (line 93) | pub(crate) fn render<'b>(&'a self, frame: &mut TerminalFrame<'b>, size: ...
  function centered_percent (line 133) | fn centered_percent(percent: u16, size: Rect, direction: Direction) -> R...

FILE: crates/burn-train/src/renderer/tui/progress.rs
  type ProgressBarState (line 14) | pub(crate) struct ProgressBarState {
    method new (line 27) | pub fn new(checkpoint: Option<usize>) -> Self {
    method update_train (line 37) | pub(crate) fn update_train(&mut self, progress: &TrainingProgress) {
    method update_valid (line 50) | pub(crate) fn update_valid(&mut self, progress: &TrainingProgress) {
    method update_test (line 62) | pub(crate) fn update_test(&mut self, progress: &EvaluationProgress) {
    method view (line 70) | pub(crate) fn view(&self) -> ProgressBarView {
  constant MINUTE (line 22) | const MINUTE: u64 = 60;
  constant HOUR (line 23) | const HOUR: u64 = 60 * 60;
  constant DAY (line 24) | const DAY: u64 = 24 * 60 * 60;
  type ProgressBarView (line 87) | pub(crate) struct ProgressBarView {
    method render (line 96) | pub(crate) fn render(self, frame: &mut TerminalFrame<'_>, size: Rect) {
  type ProgressEstimate (line 152) | struct ProgressEstimate {
    method new (line 160) | fn new() -> Self {
    method secs (line 169) | fn secs(&self) -> Option<u64> {
    method update (line 183) | fn update(&mut self, progress: &TrainingProgress, starting_epoch: usiz...
    method init (line 205) | fn init(&mut self, progress: &TrainingProgress, starting_epoch: usize) {
  function calculate_progress (line 222) | fn calculate_progress(
  function format_eta (line 242) | fn format_eta(eta_secs: u64) -> String {
  function test_format_eta (line 273) | fn test_format_eta() {
  function calculate_progress_for_eta (line 284) | fn calculate_progress_for_eta() {
  function calculate_progress_for_eta_with_warmup (line 307) | fn calculate_progress_for_eta_with_warmup() {

FILE: crates/burn-train/src/renderer/tui/recent_history.rs
  constant FACTOR_BEFORE_RESIZE (line 10) | const FACTOR_BEFORE_RESIZE: usize = 2;
  type RecentHistoryPlot (line 13) | pub(crate) struct RecentHistoryPlot {
    method new (line 31) | pub(crate) fn new(max_samples: usize) -> Self {
    method push (line 39) | pub(crate) fn push(&mut self, tag: TuiTag, data: f64) {
    method datasets (line 57) | pub(crate) fn datasets(&self) -> Vec<Dataset<'_>> {
    method point_x (line 67) | fn point_x(&mut self) -> (f64, f64) {
    method update_bounds (line 83) | fn update_bounds(&mut self) {
  type RecentHistoryPoints (line 19) | struct RecentHistoryPoints {
    method new (line 99) | fn new(max_samples: usize) -> Self {
    method push (line 114) | fn push(&mut self, (x, y): (f64, f64)) {
    method update_cursor (line 130) | fn update_cursor(&mut self, min_x: f64) {
    method slice (line 167) | fn slice(&self) -> &[(f64, f64)] {
    method calculate_max_y (line 171) | fn calculate_max_y(&self) -> f64 {
    method calculate_min_y (line 181) | fn calculate_min_y(&self) -> f64 {
    method resize (line 193) | fn resize(&mut self) {
    method dataset (line 204) | fn dataset<'a>(&'a self, name: String, color: Color) -> Dataset<'a> {
  function test_push_update_bounds_max_y (line 223) | fn test_push_update_bounds_max_y() {
  function test_push_update_bounds_min_y (line 237) | fn test_push_update_bounds_min_y() {

FILE: crates/burn-train/src/renderer/tui/renderer.rs
  type TerminalBackend (line 35) | pub(crate) type TerminalBackend = CrosstermBackend<Stdout>;
  type TerminalFrame (line 37) | pub(crate) type TerminalFrame<'a> = ratatui::Frame<'a>;
  type PanicHook (line 39) | type PanicHook = Box<dyn Fn(&std::panic::PanicHookInfo<'_>) + 'static + ...
  constant MAX_REFRESH_RATE_MILLIS (line 41) | const MAX_REFRESH_RATE_MILLIS: u64 = 100;
  type TuiRendererEvent (line 43) | enum TuiRendererEvent {
  type TuiMetricsRendererWrapper (line 59) | pub struct TuiMetricsRendererWrapper {
    method new (line 68) | pub fn new(interrupter: Interrupter, checkpoint: Option<usize>) -> Self {
    method send_event (line 115) | fn send_event(&self, event: TuiRendererEvent) {
    method persistent (line 125) | pub fn persistent(self) -> Self {
  type TuiMetricsRenderer (line 131) | struct TuiMetricsRenderer {
    method update_metric (line 241) | fn update_metric(&mut self, split: TuiSplit, group: TuiGroup, state: M...
    method new (line 268) | pub fn new(
    method handle_event (line 309) | fn handle_event(&mut self, event: TuiRendererEvent) {
    method render (line 355) | fn render(&mut self) -> Result<(), Box<dyn Error>> {
    method draw (line 364) | fn draw(&mut self) -> Result<(), Box<dyn Error>> {
    method handle_user_input (line 387) | fn handle_user_input(&mut self) -> Result<(), Box<dyn Error>> {
    method handle_post_training (line 432) | fn handle_post_training(&mut self) -> Result<(), Box<dyn Error>> {
    method reset (line 476) | fn reset(&mut self) -> Result<(), Box<dyn Error>> {
  method update_test (line 150) | fn update_test(&mut self, name: EvaluationName, state: MetricState) {
  method render_test (line 158) | fn render_test(&mut self, item: EvaluationProgress, progress_indicators:...
  method on_test_end (line 165) | fn on_test_end(&mut self, summary: Option<LearnerSummary>) -> Result<(),...
  method manual_close (line 176) | fn manual_close(&mut self) {
  method register_metric (line 181) | fn register_metric(&mut self, definition: MetricDefinition) {
  method update_train (line 187) | fn update_train(&mut self, state: MetricState) {
  method update_valid (line 195) | fn update_valid(&mut self, state: MetricState) {
  method render_train (line 203) | fn render_train(&mut self, item: TrainingProgress, progress_indicators: ...
  method render_valid (line 211) | fn render_valid(&mut self, item: TrainingProgress, progress_indicators: ...
  method on_train_end (line 219) | fn on_train_end(&mut self, summary: Option<LearnerSummary>) -> Result<()...
  method drop (line 232) | fn drop(&mut self) {
  type QuitPopupAccept (line 501) | struct QuitPopupAccept(Interrupter);
  type KillPopupAccept (line 502) | struct KillPopupAccept(Sender<()>);
  type PopupCancel (line 503) | struct PopupCancel;
  method call (line 506) | fn call(&self) -> bool {
  method call (line 513) | fn call(&self) -> bool {
  method call (line 520) | fn call(&self) -> bool {
  method drop (line 526) | fn drop(&mut self) {

FILE: crates/burn-train/src/renderer/tui/status.rs
  type StatusState (line 12) | pub(crate) struct StatusState {
    method update_train (line 34) | pub(crate) fn update_train(&mut self, progress_indicators: Vec<Progres...
    method update_valid (line 39) | pub(crate) fn update_valid(&mut self, progress_indicators: Vec<Progres...
    method update_test (line 44) | pub(crate) fn update_test(&mut self, progress_indicators: Vec<Progress...
    method view (line 49) | pub(crate) fn view(&self) -> StatusView {
  type Mode (line 17) | enum Mode {
  method default (line 24) | fn default() -> Self {
  type StatusView (line 54) | pub(crate) struct StatusView {
    method new (line 59) | fn new(progress_indicators: &[ProgressType], mode: &Mode) -> Self {
    method render (line 102) | pub(crate) fn render(self, frame: &mut TerminalFrame<'_>, size: Rect) {

FILE: crates/burn-vision/src/backends/cpu/base.rs
  type MinMax (line 1) | pub trait MinMax {
    method min (line 2) | fn min(self, other: Self) -> Self;
    method max (line 3) | fn max(self, other: Self) -> Self;
    method min (line 25) | fn min(self, other: Self) -> Self {
    method max (line 29) | fn max(self, other: Self) -> Self {
    method min (line 35) | fn min(self, other: Self) -> Self {
    method max (line 39) | fn max(self, other: Self) -> Self {

FILE: crates/burn-vision/src/backends/cpu/connected_components.rs
  function connected_components (line 59) | pub fn connected_components<B: Backend>(
  function connected_components_with_stats (line 66) | pub fn connected_components_with_stats<B: Backend>(
  function run (line 81) | fn run<B: Backend, I: ElementOrdered, Stats: StatsOp<Label = I>>(
  type Solver (line 111) | pub trait Solver {
    method init (line 114) | fn init(max_labels: usize) -> Self;
    method merge (line 116) | fn merge(label_1: Self::Label, label_2: Self::Label, solver: &mut Self...
    method new_label (line 117) | fn new_label(&mut self) -> Self::Label;
    method flatten (line 118) | fn flatten(&mut self) -> Self::Label;
    method get_label (line 119) | fn get_label(&self, i_label: Self::Label) -> Self::Label;
    type Label (line 127) | type Label = I;
    method init (line 129) | fn init(max_labels: usize) -> Self {
    method merge (line 135) | fn merge(mut label_1: I, mut label_2: I, solver: &mut Self) -> I {
    method new_label (line 155) | fn new_label(&mut self) -> I {
    method flatten (line 161) | fn flatten(&mut self) -> I {
    method get_label (line 174) | fn get_label(&self, i_label: I) -> I {
  type UnionFind (line 122) | pub(crate) struct UnionFind<I: Element> {
  type StatsOp (line 179) | pub trait StatsOp {
    method init (line 182) | fn init(&mut self, num_labels: usize);
    method update (line 183) | fn update(&mut self, row: usize, column: usize, label: Self::Label);
    method finish (line 184) | fn finish(&mut self);
    type Label (line 193) | type Label = I;
    method init (line 195) | fn init(&mut self, _num_labels: usize) {}
    method update (line 197) | fn update(&mut self, _row: usize, _column: usize, _label: Self::Label) {}
    method finish (line 199) | fn finish(&mut self) {}
    type Label (line 212) | type Label = I;
    method init (line 214) | fn init(&mut self, num_labels: usize) {
    method update (line 222) | fn update(&mut self, row: usize, column: usize, label: I) {
    method finish (line 238) | fn finish(&mut self) {
  type NoOp (line 188) | struct NoOp<I: Element> {
  type ConnectedStatsOp (line 203) | struct ConnectedStatsOp<I: Element> {
  function finalize_stats (line 248) | fn finalize_stats<B: Backend, I: Element>(
  function max_labels (line 274) | pub fn max_labels(h: usize, w: usize, conn: Connectivity) -> usize {

FILE: crates/burn-vision/src/backends/cpu/connected_components/spaghetti/Spaghetti_forest_labels.rs
  type centerLabels (line 11) | pub enum centerLabels {
  type firstLabels (line 121) | pub enum firstLabels {
  type lastLabels (line 141) | pub enum lastLabels {
  type singleLabels (line 181) | pub enum singleLabels {

FILE: crates/burn-vision/src/backends/cpu/connected_components/spaghetti/mod.rs
  function process (line 32) | pub fn process<B: Element, LabelsSolver: Solver>(

FILE: crates/burn-vision/src/backends/cpu/connected_components/spaghetti_4c/Spaghetti4C_forest_labels.rs
  type centerLabels (line 11) | pub enum centerLabels {
  type firstLabels (line 17) | pub enum firstLabels {

FILE: crates/burn-vision/src/backends/cpu/connected_components/spaghetti_4c/mod.rs
  function process (line 27) | pub fn process<B: Element, LabelsSolver: Solver>(

FILE: crates/burn-vision/src/backends/cpu/morphology/filter.rs
  type MorphOperator (line 12) | pub trait MorphOperator<T> {
    method apply (line 13) | fn apply(a: T, b: T) -> T;
  type VecMorphOperator (line 16) | pub trait VecMorphOperator<T: Scalar> {
    method apply (line 17) | fn apply<S: Simd>(a: Vector<S, T>, b: Vector<S, T>) -> Vector<S, T>;
  type MinOp (line 20) | pub struct MinOp;
    method apply (line 24) | fn apply(a: T, b: T) -> T {
    method apply (line 30) | fn apply<S: Simd>(a: Vector<S, T>, b: Vector<S, T>) -> Vector<S, T> {
  type MaxOp (line 21) | pub struct MaxOp;
    method apply (line 36) | fn apply(a: T, b: T) -> T {
    method apply (line 42) | fn apply<S: Simd>(a: Vector<S, T>, b: Vector<S, T>) -> Vector<S, T> {
  type MorphRowFilter (line 47) | pub struct MorphRowFilter<T: Scalar, S: MorphOperator<T>, Vec: VecRow<T>> {
  function new (line 56) | pub fn new(ksize: usize, anchor: usize) -> Self {
  function apply (line 67) | pub fn apply<S: Simd>(&self, src: &[T], dst: &mut [T], width: usize, ch:...
  type MorphRowVec (line 104) | pub struct MorphRowVec<T: Scalar, Op: VecMorphOperator<T>> {
  type VecRow (line 110) | pub trait VecRow<T: Scalar> {
    method new (line 111) | fn new(ksize: usize, anchor: usize) -> Self;
    method apply (line 112) | fn apply<S: Simd>(&self, src: &[T], dst: &mut [T], width: usize, chann...
  function apply (line 116) | fn apply<S: Simd>(&self, src: &[T], dst: &mut [T], width: usize, ch: usi...
  function new (line 175) | fn new(k_size: usize, _anchor: usize) -> Self {
  type VecColumn (line 184) | pub trait VecColumn<T: Scalar> {
    method new (line 185) | fn new(ksize: usize, anchor: usize) -> Self;
    method apply (line 186) | fn apply<S: Simd>(
  type MorphColumnVec (line 197) | pub struct MorphColumnVec<T: Scalar, Op: VecMorphOperator<T>> {
  function new (line 204) | fn new(k_size: usize, _anchor: usize) -> Self {
  function apply (line 212) | fn apply<S: Simd>(
  type MorphColumnFilter (line 418) | pub struct MorphColumnFilter<T: Scalar, Op: MorphOperator<T>, VecOp: Vec...
  function new (line 427) | pub fn new(ksize: usize, anchor: usize) -> Self {
  function apply (line 438) | pub fn apply<S: Simd>(
  type VecFilter (line 548) | pub trait VecFilter<T: Scalar> {
    method apply (line 549) | fn apply<S: Simd>(src: &[*const T], nz: usize, dst: &mut [T], width: u...
  type MorphVec (line 552) | pub struct MorphVec<T: Scalar, Op: VecMorphOperator<T>>(PhantomData<(T, ...
  function apply (line 555) | fn apply<S: Simd>(src: &[*const T], nz: usize, dst: &mut [T], width: usi...
  type MorphFilter (line 614) | pub struct MorphFilter<T: Scalar, Op: MorphOperator<T>, VecOp: VecFilter...
  function new (line 623) | pub fn new<B: Element>(kernel: &[B], ksize: Size, anchor: Point) -> Self {
  function apply (line 637) | pub fn apply<S: Simd>(
  function process_2d_kernel (line 700) | fn process_2d_kernel<B: Element>(kernel: &[B], ksize: Size) -> Vec<Point> {

FILE: crates/burn-vision/src/backends/cpu/morphology/filter_engine.rs
  type RowFilter (line 14) | pub type RowFilter<T, Op> = MorphRowFilter<T, Op, MorphRowVec<T, Op>>;
  type ColFilter (line 15) | pub type ColFilter<T, Op> = MorphColumnFilter<T, Op, MorphColumnVec<T, O...
  type Filter2D (line 16) | pub type Filter2D<T, Op> = MorphFilter<T, Op, MorphVec<T, Op>>;
  type Filter (line 18) | pub enum Filter<T: VOrd, Op: MorphOperator<T> + VecMorphOperator<T>> {
  type FilterEngine (line 26) | pub struct FilterEngine<S: Simd, T: VOrd, Op: MorphOperator<T> + VecMorp...
  function resize_ring_buf (line 57) | fn resize_ring_buf(&mut self, size: usize) {
  function resize_src_row (line 61) | fn resize_src_row(&mut self, size: usize) {
  function is_separable (line 65) | fn is_separable(&self) -> bool {
  function new (line 71) | pub fn new(
  function apply (line 126) | pub fn apply(&mut self, tensor: &mut [T], src_shape: Shape) {
  function start (line 139) | pub fn start(&mut self, shape: Shape) -> usize {
  function proceed (line 243) | pub fn proceed(
  function remaining_input_rows (line 361) | fn remaining_input_rows(&self) -> usize {
  function memcpy (line 367) | fn memcpy<T: Copy>(to: &mut [T], from: &[T], len: usize) {
  function alias_slice_mut (line 373) | fn alias_slice_mut<'b, T>(slice: &mut [T]) -> &'b mut [T] {
  function border_interpolate (line 379) | fn border_interpolate(mut p: isize, len: usize, btype: BorderType) -> is...

FILE: crates/burn-vision/src/backends/cpu/morphology/mod.rs
  type MorphOp (line 21) | pub enum MorphOp {
  type MorphKernel (line 26) | pub enum MorphKernel<B: Element> {
  function morph (line 38) | pub fn morph<B: Backend, K: BasicOps<B>>(
  function morph_typed (line 117) | fn morph_typed<B: Backend, K: BasicOps<B>, T: VOrd + MinMax + Element>(
  function morph_bool (line 134) | fn morph_bool<B: Backend, K: BasicOps<B>>(
  function border_value (line 152) | fn border_value<T: Element>(
  function run_morph (line 169) | fn run_morph<T: VOrd + MinMax + Element, B: Element>(
  function filter (line 190) | fn filter<T: VOrd + MinMax, Op: MorphOperator<T> + VecMorphOperator<T>, ...
  function dispatch_morph (line 216) | fn dispatch_morph<
  type KernelShape (line 241) | pub enum KernelShape {
  function create_structuring_element (line 251) | pub fn create_structuring_element<B: Backend>(

FILE: crates/burn-vision/src/backends/cpu/nms.rs
  function nms (line 13) | pub fn nms<B: Backend>(
  function nms_vec (line 38) | fn nms_vec(boxes_vec: Vec<f32>, scores_vec: Vec<f32>, options: NmsOption...
  function suppress_overlapping (line 127) | fn suppress_overlapping<'a, S: Simd>(

FILE: crates/burn-vision/src/backends/cube/connected_components/hardware_accelerated.rs
  constant BLOCK_H (line 20) | const BLOCK_H: usize = 4;
  function merge (line 23) | fn merge<I: Int>(labels: &Tensor<Atomic<I>>, label_1: u32, label_2: u32) {
  function start_distance (line 50) | fn start_distance(pixels: u32, tx: u32) -> u32 {
  function end_distance (line 55) | fn end_distance(pixels: u32, tx: u32) -> u32 {
  function ballot_dyn (line 61) | fn ballot_dyn(y: u32, pred: bool) -> u32 {
  function strip_labeling (line 67) | fn strip_labeling<I: Int, BT: CubePrimitive>(
  function strip_merge (line 194) | fn strip_merge<I: Int, BT: CubePrimitive>(
  function relabeling (line 297) | fn relabeling<I: Int, BT: CubePrimitive>(img: &Tensor<BT>, labels: &mut ...
  function analysis (line 337) | fn analysis<I: Int, BT: CubePrimitive>(
  function compact_labels (line 402) | fn compact_labels<I: Int>(
  function compact_stats (line 425) | fn compact_stats<I: Int>(
  function hardware_accelerated (line 459) | pub fn hardware_accelerated<R: CubeRuntime, F: FloatElement, I: IntEleme...

FILE: crates/burn-vision/src/backends/cube/connected_components/mod.rs
  function stats_from_opts (line 17) | pub(crate) fn stats_from_opts<R, F, I, BT>(

FILE: crates/burn-vision/src/backends/cube/connected_components/prefix_sum.rs
  constant CUBE_SIZE (line 13) | const CUBE_SIZE: usize = 256;
  constant MIN_SUBGROUP_SIZE (line 14) | const MIN_SUBGROUP_SIZE: usize = 4;
  constant MAX_REDUCE_SIZE (line 15) | const MAX_REDUCE_SIZE: usize = CUBE_SIZE / MIN_SUBGROUP_SIZE;
  constant PART_SIZE (line 17) | const PART_SIZE: usize = 4096;
  function prefix_sum_kernel (line 20) | fn prefix_sum_kernel<I: Int, N: Size>(
  function count_trailing_zeros (line 216) | fn count_trailing_zeros(num: u32) -> u32 {
  function prefix_sum (line 221) | pub fn prefix_sum<R: CubeRuntime, I: IntElement>(input: CubeTensor<R>) -...

FILE: crates/burn-vision/src/backends/cube/ops.rs
  method connected_components (line 21) | fn connected_components(img: BoolTensor<Self>, connectivity: Connectivit...
  method connected_components_with_stats (line 31) | fn connected_components_with_stats(
  method connected_components (line 86) | fn connected_components(img: BoolTensor<Self>, conn: Connectivity) -> In...
  method connected_components_with_stats (line 130) | fn connected_components_with_stats(

FILE: crates/burn-vision/src/base.rs
  type Size (line 5) | pub struct Size {
  type Point (line 14) | pub struct Point {

FILE: crates/burn-vision/src/ops/base.rs
  type Connectivity (line 14) | pub enum Connectivity {
  type ConnectedStatsOptions (line 26) | pub struct ConnectedStatsOptions {
    method none (line 148) | pub fn none() -> Self {
    method all (line 157) | pub fn all() -> Self {
  type MorphOptions (line 37) | pub struct MorphOptions<B: Backend, K: TensorKind<B>> {
  method default (line 51) | fn default() -> Self {
  type BorderType (line 63) | pub enum BorderType {
  type ConnectedStats (line 82) | pub struct ConnectedStats<B: Backend> {
  type ConnectedStatsPrimitive (line 98) | pub struct ConnectedStatsPrimitive<B: Backend> {
  function from (line 114) | fn from(value: ConnectedStatsPrimitive<B>) -> Self {
  function into_primitive (line 128) | pub fn into_primitive(self) -> ConnectedStatsPrimitive<B> {
  method default (line 141) | fn default() -> Self {
  type NmsOptions (line 168) | pub struct NmsOptions {
  method default (line 180) | fn default() -> Self {
  type VisionBackend (line 190) | pub trait VisionBackend:
  type BoolVisionOps (line 196) | pub trait BoolVisionOps: Backend {
    method connected_components (line 201) | fn connected_components(img: BoolTensor<Self>, connectivity: Connectiv...
    method connected_components_with_stats (line 210) | fn connected_components_with_stats(
    method bool_erode (line 219) | fn bool_erode(
    method bool_dilate (line 229) | fn bool_dilate(
  type IntVisionOps (line 240) | pub trait IntVisionOps: Backend {
    method int_erode (line 242) | fn int_erode(
    method int_dilate (line 252) | fn int_dilate(
  type FloatVisionOps (line 263) | pub trait FloatVisionOps: Backend {
    method float_erode (line 265) | fn float_erode(
    method float_dilate (line 278) | fn float_dilate(
    method nms (line 302) | fn nms(
  type QVisionOps (line 314) | pub trait QVisionOps: Backend {
    method q_erode (line 316) | fn q_erode(
    method q_dilate (line 329) | fn q_dilate(

FILE: crates/burn-vision/src/tensor.rs
  type ConnectedComponents (line 12) | pub trait ConnectedComponents<B: Backend> {
    method connected_components (line 17) | fn connected_components(self, connectivity: Connectivity) -> Tensor<B,...
    method connected_components_with_stats (line 24) | fn connected_components_with_stats(
  type Morphology (line 32) | pub trait Morphology<B: Backend, K: TensorKind<B>> {
    method erode (line 35) | fn erode(self, kernel: Tensor<B, 2, Bool>, opts: MorphOptions<B, K>) -...
    method dilate (line 38) | fn dilate(self, kernel: Tensor<B, 2, Bool>, opts: MorphOptions<B, K>) ...
  type MorphologyKind (line 42) | pub trait MorphologyKind<B: Backend>: BasicOps<B> {
    method erode (line 44) | fn erode(
    method dilate (line 50) | fn dilate(
  type Nms (line 58) | pub trait Nms<B: Backend> {
    method nms (line 72) | fn nms(self, scores: Tensor<B, 1, Float>, opts: NmsOptions) -> Tensor<...
  function connected_components (line 76) | fn connected_components(self, connectivity: Connectivity) -> Tensor<B, 2...
  function connected_components_with_stats (line 80) | fn connected_components_with_stats(
  function erode (line 92) | fn erode(self, kernel: Tensor<B, 2, Bool>, opts: MorphOptions<B, K>) -> ...
  function dilate (line 100) | fn dilate(self, kernel: Tensor<B, 2, Bool>, opts: MorphOptions<B, K>) ->...
  method erode (line 110) | fn erode(
  method dilate (line 125) | fn dilate(
  method erode (line 142) | fn erode(
  method dilate (line 150) | fn dilate(
  method erode (line 160) | fn erode(
  method dilate (line 168) | fn dilate(
  function nms (line 178) | fn nms(self, scores: Tensor<B, 1>, options: NmsOptions) -> Tensor<B, 1, ...

FILE: crates/burn-vision/src/transform/transform2d.rs
  type Transform2D (line 11) | pub struct Transform2D {
    method transform (line 25) | pub fn transform<B: Backend>(self, img: Tensor<B, 4>) -> Tensor<B, 4> {
    method composed (line 38) | pub fn composed<I: IntoIterator<Item = Self>>(transforms: I) -> Self {
    method mul (line 47) | fn mul(self, other: Transform2D) -> Transform2D {
    method identity (line 72) | pub fn identity() -> Self {
    method rotation (line 83) | pub fn rotation(theta: f32, cx: f32, cy: f32) -> Self {
    method scale (line 101) | pub fn scale(sx: f32, sy: f32, cx: f32, cy: f32) -> Self {
    method translation (line 111) | pub fn translation(tx: f32, ty: f32) -> Self {
    method shear (line 127) | pub fn shear(shx: f32, shy: f32, cx: f32, cy: f32) -> Self {
  type B (line 139) | type B = NdArray;
  function transform_identity_translation (line 142) | fn transform_identity_translation() {
  function transform_translation (line 152) | fn transform_translation() {
  function transform_rotation_90_degrees (line 164) | fn transform_rotation_90_degrees() {
  function transform_rotation_around_corner (line 175) | fn transform_rotation_around_corner() {
  function transform_scale (line 189) | fn transform_scale() {
  function transform_scale_around_corner (line 202) | fn transform_scale_around_corner() {
  function transform_combined (line 215) | fn transform_combined() {

FILE: crates/burn-vision/src/utils/save.rs
  type TensorDisplayOptions (line 9) | pub struct TensorDisplayOptions {
  type ImageDimOrder (line 23) | pub enum ImageDimOrder {
  type ColorDisplayOpts (line 39) | pub enum ColorDisplayOpts {
  type BatchDisplayOpts (line 53) | pub enum BatchDisplayOpts {
  function save_tensor_as_image (line 65) | pub fn save_tensor_as_image<B: Backend, const D: usize, P: AsRef<std::ff...
  function normalize (line 183) | fn normalize<B: Backend, const D: usize>(tensor: Tensor<B, D>) -> Tensor...

FILE: crates/burn-vision/tests/common/mod.rs
  type TestBackend (line 12) | pub type TestBackend = burn_ndarray::NdArray<f32, i32>;
  type TestBackend (line 15) | pub type TestBackend = burn_wgpu::Wgpu;
  type TestBackend (line 18) | pub type TestBackend = burn_cuda::Cuda;
  type TestTensor (line 21) | pub type TestTensor<const D: usize> = burn_tensor::Tensor<TestBackend, D>;
  type TestTensorInt (line 22) | pub type TestTensorInt<const D: usize> = burn_tensor::Tensor<TestBackend...
  type TestTensorBool (line 24) | pub type TestTensorBool<const D: usize> = burn_tensor::Tensor<TestBacken...
  type IntType (line 27) | pub type IntType = <TestBackend as burn_tensor::backend::Backend>::IntElem;
  function test_image (line 48) | pub fn test_image<B: Backend>(name: &str, device: &B::Device, luma: bool...
  function save_test_image (line 67) | pub fn save_test_image<B: Backend>(name: &str, tensor: Tensor<B, 3>, lum...

FILE: crates/burn-vision/tests/connected_components.rs
  function space_invader (line 11) | fn space_invader() -> [[IntType; 14]; 9] {
  function should_support_8_connectivity (line 26) | fn should_support_8_connectivity() {
  function should_support_8_connectivity_with_stats (line 37) | fn should_support_8_connectivity_with_stats() {
  function should_support_4_connectivity (line 67) | fn should_support_4_connectivity() {
  function should_support_4_connectivity_with_stats (line 88) | fn should_support_4_connectivity_with_stats() {
  function normalize_labels (line 130) | fn normalize_labels(mut labels: TensorData) -> TensorData {

FILE: crates/burn-vision/tests/morphology.rs
  type FT (line 5) | type FT = FloatElem<TestBackend>;
  function should_support_dilate_luma (line 11) | fn should_support_dilate_luma() {
  function should_support_dilate_luma_cross (line 34) | fn should_support_dilate_luma_cross() {
  function should_support_dilate_luma_ellipse (line 57) | fn should_support_dilate_luma_ellipse() {
  function should_support_dilate_luma_non_square_rect (line 80) | fn should_support_dilate_luma_non_square_rect() {
  function should_support_dilate_luma_non_square_cross (line 103) | fn should_support_dilate_luma_non_square_cross() {
  function should_support_dilate_rgb_rect (line 126) | fn should_support_dilate_rgb_rect() {
  function should_support_dilate_rgb_cross (line 149) | fn should_support_dilate_rgb_cross() {
  function should_support_dilate_rgb_border_reflect_rect (line 172) | fn should_support_dilate_rgb_border_reflect_rect() {
  function should_support_dilate_rgb_border_reflect_cross (line 200) | fn should_support_dilate_rgb_border_reflect_cross() {
  function should_support_dilate_rgb_border_reflect101_rect (line 228) | fn should_support_dilate_rgb_border_reflect101_rect() {
  function should_support_dilate_rgb_border_reflect101_cross (line 256) | fn should_support_dilate_rgb_border_reflect101_cross() {
  function should_support_dilate_rgb_border_replicate_rect (line 284) | fn should_support_dilate_rgb_border_replicate_rect() {
  function should_support_dilate_rgb_border_replicate_cross (line 312) | fn should_support_dilate_rgb_border_replicate_cross() {
  function should_support_dilate_rgb_anchor_rect (line 340) | fn should_support_dilate_rgb_anchor_rect() {
  function should_support_dilate_rgb_anchor_cross (line 366) | fn should_support_dilate_rgb_anchor_cross() {
  function should_support_dilate_boolean_rect (line 397) | fn should_support_dilate_boolean_rect() {
  function should_support_dilate_boolean_cross (line 423) | fn should_support_dilate_boolean_cross() {
  function should_support_dilate_int_rect (line 449) | fn should_support_dilate_int_rect() {
  function should_support_dilate_int_cross (line 475) | fn should_support_dilate_int_cross() {
  function should_support_erode_luma (line 501) | fn should_support_erode_luma() {
  function should_support_erode_luma_cross (line 521) | fn should_support_erode_luma_cross() {
  function should_support_erode_luma_ellipse (line 544) | fn should_support_erode_luma_ellipse() {
  function create_structuring_element_should_match_manual_rect (line 567) | fn create_structuring_element_should_match_manual_rect() {
  function create_structuring_element_should_match_manual_cross (line 592) | fn create_structuring_element_should_match_manual_cross() {
  function create_structuring_element_should_match_manual_ellipse (line 616) | fn create_structuring_element_should_match_manual_ellipse() {

FILE: crates/burn-vision/tests/nms.rs
  function should_suppress_non_maximum (line 7) | fn should_suppress_non_maximum() {
  function should_apply_score_threshold (line 29) | fn should_apply_score_threshold() {
  function should_apply_iou_threshold (line 51) | fn should_apply_iou_threshold() {
  function should_apply_max_output_boxes (line 73) | fn should_apply_max_output_boxes() {

FILE: crates/burn-wgpu/src/lib.rs
  type Wgpu (line 63) | pub type Wgpu<F = f32, I = i32, B = u32> =
  type Wgpu (line 98) | pub type Wgpu<F = f32, I = i32, B = u32> = CubeBackend<cubecl::wgpu::Wgp...
  type Vulkan (line 102) | pub type Vulkan<F = f32, I = i32, B = u8> = Wgpu<F, I, B>;
  type WebGpu (line 106) | pub type WebGpu<F = f32, I = i32, B = u32> = Wgpu<F, I, B>;
  type Metal (line 110) | pub type Metal<F = f32, I = i32, B = u8> = Wgpu<F, I, B>;
  function should_support_dtypes (line 118) | fn should_support_dtypes() {

FILE: examples/custom-csv-dataset/examples/custom-csv-dataset.rs
  function main (line 4) | fn main() {

FILE: examples/custom-csv-dataset/examples/dataframe-dataset.rs
  function main (line 4) | fn main() {

FILE: examples/custom-csv-dataset/src/dataframe_dataset.rs
  type DiabetesDataframeDataset (line 5) | pub struct DiabetesDataframeDataset {
    method new (line 10) | pub fn new() -> Result<Self, Box<dyn std::error::Error>> {
    method get (line 61) | fn get(&self, index: usize) -> Option<DiabetesPatient> {
    method len (line 65) | fn len(&self) -> usize {
  method default (line 54) | fn default() -> Self {

FILE: examples/custom-csv-dataset/src/dataset.rs
  type DiabetesDataset (line 12) | pub struct DiabetesDataset {
    method new (line 17) | pub fn new() -> Result<Self, std::io::Error> {
    method get (line 35) | fn get(&self, index: usize) -> Option<DiabetesPatient> {
    method len (line 39) | fn len(&self) -> usize {

FILE: examples/custom-csv-dataset/src/diabetes_patient.rs
  type DiabetesPatient (line 7) | pub struct DiabetesPatient {

FILE: examples/custom-csv-dataset/src/utils.rs
  function download_csv_if_missing (line 9) | pub fn download_csv_if_missing() -> PathBuf {

FILE: examples/custom-cubecl-kernel/examples/custom-cubecl-kernel.rs
  function inference (line 9) | fn inference<B: Backend>(device: &B::Device) {
  function autodiff (line 26) | fn autodiff<B: AutodiffBackend>(device: &B::Device) {
  function main (line 82) | fn main() {

FILE: examples/custom-cubecl-kernel/src/backward.rs
  method fused_matmul_add_relu (line 22) | fn fused_matmul_add_relu(

FILE: examples/custom-cubecl-kernel/src/forward.rs
  method fused_matmul_add_relu (line 15) | fn fused_matmul_add_relu(

FILE: examples/custom-cubecl-kernel/src/kernel.rs
  function fused_matmul_add_relu_kernel (line 5) | pub fn fused_matmul_add_relu_kernel<F: Float>(

FILE: examples/custom-cubecl-kernel/src/lib.rs
  type Backend (line 8) | pub trait Backend: burn::tensor::backend::Backend {
    method fused_matmul_add_relu (line 9) | fn fused_matmul_add_relu(
  type AutodiffBackend (line 17) | pub trait AutodiffBackend: Backend + burn::tensor::backend::AutodiffBack...
  function matmul_add_relu_custom (line 20) | pub fn matmul_add_relu_custom<B: Backend>(
  function matmul_add_relu_reference (line 35) | pub fn matmul_add_relu_reference<B: Backend>(

FILE: examples/custom-image-dataset/examples/custom-image-dataset.rs
  function create_config (line 11) | fn create_config() -> TrainingConfig {
  function main (line 19) | fn main() {

FILE: examples/custom-image-dataset/src/data.rs
  constant MEAN (line 10) | const MEAN: [f32; 3] = [0.4914, 0.48216, 0.44653];
  constant STD (line 11) | const STD: [f32; 3] = [0.24703, 0.24349, 0.26159];
  type Normalizer (line 15) | pub struct Normalizer<B: Backend> {
  function new (line 22) | pub fn new(device: &Device<B>) -> Self {
  function normalize (line 35) | pub fn normalize(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
  function to_device (line 40) | pub fn to_device(&self, device: &B::Device) -> Self {
  type ClassificationBatcher (line 49) | pub struct ClassificationBatcher<B: Backend> {
  type ClassificationBatch (line 54) | pub struct ClassificationBatch<B: Backend> {
  function new (line 61) | pub fn new(device: B::Device) -> Self {
  function batch (line 69) | fn batch(&self, items: Vec<ImageDatasetItem>, device: &B::Device) -> Cla...

FILE: examples/custom-image-dataset/src/dataset.rs
  constant URL (line 9) | const URL: &str = "https://s3.amazonaws.com/fast-ai-sample/cifar10.tgz";
  type CIFAR10Loader (line 16) | pub trait CIFAR10Loader {
    method cifar10_train (line 17) | fn cifar10_train() -> Self;
    method cifar10_test (line 18) | fn cifar10_test() -> Self;
    method cifar10_train (line 23) | fn cifar10_train() -> Self {
    method cifar10_test (line 30) | fn cifar10_test() -> Self {
  function download (line 38) | fn download() -> PathBuf {

FILE: examples/custom-image-dataset/src/inference.rs
  constant NUM_CLASSES (line 13) | const NUM_CLASSES: u8 = 10;
  function infer (line 15) | pub fn infer<B: Backend>(artifact_dir: &str, device: B::Device, item: Im...

FILE: examples/custom-image-dataset/src/model.rs
  type Cnn (line 25) | pub struct Cnn<B: Backend> {
  function new (line 40) | pub fn new(num_classes: usize, device: &Device<B>) -> Self {
  function forward (line 84) | pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 2> {

FILE: examples/custom-image-dataset/src/training.rs
  constant NUM_CLASSES (line 21) | const NUM_CLASSES: u8 = 10;
  constant ARTIFACT_DIR (line 22) | const ARTIFACT_DIR: &str = "/tmp/custom-image-dataset";
  function forward_classification (line 25) | pub fn forward_classification(
  type Input (line 40) | type Input = ClassificationBatch<B>;
  type Output (line 41) | type Output = ClassificationOutput<B>;
  method step (line 43) | fn step(&self, batch: ClassificationBatch<B>) -> TrainOutput<Classificat...
  type Input (line 51) | type Input = ClassificationBatch<B>;
  type Output (line 52) | type Output = ClassificationOutput<B>;
  method step (line 54) | fn step(&self, batch: ClassificationBatch<B>) -> ClassificationOutput<B> {
  type TrainingConfig (line 60) | pub struct TrainingConfig {
  function create_artifact_dir (line 74) | fn create_artifact_dir(artifact_dir: &str) {
  function train (line 80) | pub fn train<B: AutodiffBackend>(config: TrainingConfig, device: B::Devi...

FILE: examples/custom-learning-strategy/examples/custom-learning-strategy.rs
  function main (line 3) | fn main() {

FILE: examples/custom-learning-strategy/src/model.rs
  type Model (line 15) | pub struct Model<B: Backend> {
  type ModelConfig (line 26) | pub struct ModelConfig {
    method init (line 35) | pub fn init<B: Backend>(&self, device: &B::Device) -> Model<B> {
  function forward (line 52) | pub fn forward(&self, images: Tensor<B, 3>) -> Tensor<B, 2> {
  function forward_classification (line 73) | pub fn forward_classification(&self, item: MnistBatch<B>) -> Classificat...
  type Input (line 89) | type Input = MnistBatch<B>;
  type Output (line 90) | type Output = ClassificationOutput<B>;
  method step (line 92) | fn step(&self, item: MnistBatch<B>) -> TrainOutput<ClassificationOutput<...
  type Input (line 99) | type Input = MnistBatch<B>;
  type Output (line 100) | type Output = ClassificationOutput<B>;
  method step (line 101) | fn step(&self, batch: MnistBatch<B>) -> ClassificationOutput<B> {

FILE: examples/custom-learning-strategy/src/training.rs
  type MnistTrainingConfig (line 38) | pub struct MnistTrainingConfig {
  function create_artifact_dir (line 53) | fn create_artifact_dir(artifact_dir: &str) {
  function run (line 59) | pub fn run<B: AutodiffBackend>(device: B::Device) {
  type MyCustomLearningStrategy (line 124) | struct MyCustomLearningStrategy<LC: LearningComponentsTypes> {
  function new (line 130) | pub fn new(device: Device<TrainingBackend<LC>>) -> Self {
  function fit (line 139) | fn fit(

FILE: examples/custom-renderer/examples/custom-renderer.rs
  function main (line 3) | fn main() {

FILE: examples/custom-renderer/src/lib.rs
  type MnistTrainingConfig (line 17) | pub struct MnistTrainingConfig {
  type CustomRenderer (line 32) | struct CustomRenderer {}
  method update_train (line 35) | fn update_train(&mut self, _state: MetricState) {}
  method update_valid (line 37) | fn update_valid(&mut self, _state: MetricState) {}
  method render_train (line 39) | fn render_train(&mut self, item: TrainingProgress, _progress_indicators:...
  method render_valid (line 43) | fn render_valid(&mut self, item: TrainingProgress, _progress_indicators:...
  method manual_close (line 49) | fn manual_close(&mut self) {
  method register_metric (line 53) | fn register_metric(&mut self, _definition: burn::train::metric::MetricDe...
  method update_test (line 57) | fn update_test(&mut self, _name: EvaluationName, _state: MetricState) {}
  method render_test (line 59) | fn render_test(&mut self, item: EvaluationProgress, _progress_indicators...
  function run (line 64) | pub fn run<B: AutodiffBackend>(device: B::Device) {

FILE: examples/custom-training-loop/examples/custom-training-loop.rs
  function main (line 3) | fn main() {

FILE: examples/custom-training-loop/src/lib.rs
  type MnistTrainingConfig (line 17) | pub struct MnistTrainingConfig {
  function run (line 32) | pub fn run<B: AutodiffBackend>(device: B::Device) {
  function accuracy (line 107) | fn accuracy<B: Backend>(output: Tensor<B, 2>, targets: Tensor<B, 1, Int>...
  type Learner1 (line 116) | struct Learner1<B, O>
  type Learner2 (line 125) | struct Learner2<M, O> {
  type Learner3 (line 131) | struct Learner3<B, M, O> {
  function step1 (line 143) | pub fn step1(&mut self, _batch: MnistBatch<B>) {
  function step2 (line 154) | pub fn step2(&mut self, _batch: MnistBatch<B>) {
  function step3 (line 161) | pub fn step3<B>(&mut self, _batch: MnistBatch<B>)

FILE: examples/custom-wgpu-kernel/examples/custom-wgpu-kernel.rs
  function inference (line 9) | fn inference<B: Backend>(device: &B::Device) {
  function autodiff (line 26) | fn autodiff<B: AutodiffBackend>(device: &B::Device) {
  function main (line 82) | fn main() {

FILE: examples/custom-wgpu-kernel/src/backward.rs
  method fused_matmul_add_relu (line 28) | fn fused_matmul_add_relu(

FILE: examples/custom-wgpu-kernel/src/forward.rs
  type FusedMatmulAddRelu (line 20) | struct FusedMatmulAddRelu<E: FloatElement> {
  method source (line 27) | fn source(&self) -> SourceTemplate {
  method id (line 38) | fn id(&self) -> KernelId {
  method fused_matmul_add_relu (line 47) | fn fused_matmul_add_relu(

FILE: examples/custom-wgpu-kernel/src/lib.rs
  type Backend (line 7) | pub trait Backend: burn::tensor::backend::Backend {
    method fused_matmul_add_relu (line 8) | fn fused_matmul_add_relu(
  type AutodiffBackend (line 16) | pub trait AutodiffBackend: Backend + burn::tensor::backend::AutodiffBack...
  function matmul_add_relu_custom (line 19) | pub fn matmul_add_relu_custom<B: Backend>(
  function matmul_add_relu_reference (line 34) | pub fn matmul_add_relu_reference<B: Backend>(

FILE: examples/dop_timer/src/event_utils.rs
  function example_instrumented_event (line 3) | pub(crate) fn example_instrumented_event() {

FILE: examples/dop_timer/src/main.rs
  type ConsoleFormat (line 28) | pub enum ConsoleFormat {
  type TracingMode (line 34) | pub enum TracingMode {
  type Args (line 46) | pub struct Args {
    method quiet (line 82) | pub fn quiet(&self) -> bool {
    method verbose (line 86) | pub fn verbose(&self) -> bool {
  function main (line 92) | async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
  function run (line 159) | fn run(args: &Args) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
  function run (line 164) | fn run(args: &Args) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
  function run (line 169) | fn run(args: &Args) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
  function run (line 174) | fn run(args: &Args) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
  function run_backend (line 179) | fn run_backend<B: Backend>(args: &Args) -> Result<(), Box<dyn Error + Se...

FILE: examples/dop_timer/src/parsers.rs
  function parse_array4 (line 4) | pub(crate) fn parse_array4(s: &str) -> Result<[usize; 4], String> {
  function parse_all_reduce_strategy (line 12) | pub(crate) fn parse_all_reduce_strategy(s: &str) -> Result<AllReduceStra...
  function parse_reduce_operation (line 26) | pub(crate) fn parse_reduce_operation(s: &str) -> Result<ReduceOperation,...

FILE: examples/dop_timer/src/workers.rs
  type WorkRequest (line 8) | pub enum WorkRequest<B: Backend> {
  type Worker (line 19) | struct Worker<B: Backend> {
  function new (line 27) | pub fn new(index: usize, device: B::Device, config: CollectiveConfig) ->...
  function dispatch_all_reduce (line 39) | pub fn dispatch_all_reduce<const R: usize>(
  function run (line 52) | pub fn run(&mut self, rx: Receiver<WorkRequest<B>>) {
  type WorkerHandle (line 71) | pub struct WorkerHandle<B: Backend> {
  function new (line 79) | pub fn new(index: usize, device: &B::Device, config: CollectiveConfig) -...
  function register (line 91) | pub fn register(&self) -> Receiver<()> {
  function device (line 97) | pub fn device(&self) -> &B::Device {
  function all_reduce (line 101) | pub fn all_reduce(&self, op: ReduceOperation, tensor: Tensor<B, 4>) -> R...

FILE: examples/dqn-agent/examples/dqn-agent.rs
  function run (line 14) | pub fn run() {
  function run (line 28) | pub fn run() {
  function run (line 46) | pub fn run() {
  function run (line 57) | pub fn run() {
  function run (line 68) | pub fn run() {
  function run (line 82) | pub fn run() {
  function run (line 93) | pub fn run() {
  function main (line 98) | fn main() {

FILE: examples/dqn-agent/src/agent.rs
  type DiscreteActionModel (line 31) | pub trait DiscreteActionModel<B: Backend>: Module<B> {
    method forward (line 34) | fn forward(&self, input: Self::Input) -> DiscreteLogitsTensor<B, 2>;
  type MlpNetConfig (line 38) | pub struct MlpNetConfig {
  type MlpNet (line 58) | pub struct MlpNet<B: Backend> {
  function new (line 66) | pub fn new(config: &MlpNetConfig, device: &B::Device) -> Self {
  type ObservationTensor (line 82) | pub struct ObservationTensor<B: Backend, const D: usize> {
  method batch (line 87) | fn batch(value: Vec<Self>) -> Self {
  method unbatch (line 94) | fn unbatch(self) -> Vec<Self> {
  function zeros_like (line 104) | fn zeros_like(sample: &Self, capacity: usize, device: &B::Device) -> Self {
  function select (line 111) | fn select(self, dim: usize, indices: Tensor<B, 1, Int>) -> Self {
  function slice_assign_inplace (line 117) | fn slice_assign_inplace(&mut self, index: usize, value: Self) {
  type Input (line 124) | type Input = ObservationTensor<B, 2>;
  function forward (line 132) | fn forward(&self, input: Self::Input) -> DiscreteLogitsTensor<B, 2> {
  type DqnAgentConfig (line 148) | pub struct DqnAgentConfig {
  type TargetModel (line 169) | pub trait TargetModel<B: Backend> {
    method soft_update (line 170) | fn soft_update(&self, that: &Self, tau: f64) -> Self;
  function soft_update (line 174) | fn soft_update(&self, that: &Self, tau: f64) -> Self {
  type DqnState (line 189) | pub struct DqnState<B: Backend, M: DiscreteActionModel<B>> {
  type Record (line 195) | type Record = M::Record;
  function into_record (line 197) | fn into_record(self) -> Self::Record {
  function load_record (line 201) | fn load_record(&self, record: Self::Record) -> Self {
  type DQN (line 210) | pub struct DQN<B: Backend, M: DiscreteActionModel<B>> {
  function new (line 216) | pub fn new(policy: M) -> Self {
  type DiscreteLogitsTensor (line 225) | pub struct DiscreteLogitsTensor<B: Backend, const D: usize> {
  method batch (line 230) | fn batch(value: Vec<Self>) -> Self {
  method unbatch (line 237) | fn unbatch(self) -> Vec<Self> {
  type DiscreteActionTensor (line 247) | pub struct DiscreteActionTensor<B: Backend, const D: usize> {
  method batch (line 252) | fn batch(value: Vec<Self>) -> Self {
  method unbatch (line 259) | fn unbatch(self) -> Vec<Self> {
  function zeros_like (line 269) | fn zeros_like(sample: &Self, capacity: usize, device: &B::Device) -> Self {
  function select (line 276) | fn select(self, dim: usize, indices: Tensor<B, 1, Int>) -> Self {
  function slice_assign_inplace (line 282) | fn slice_assign_inplace(&mut self, index: usize, value: Self) {
  type Observation (line 289) | type Observation = M::Input;
  type ActionDistribution (line 290) | type ActionDistribution = DiscreteLogitsTensor<B, 2>;
  type Action (line 291) | type Action = DiscreteActionTensor<B, 2>;
  type ActionContext (line 293) | type ActionContext = ();
  type PolicyState (line 294) | type PolicyState = DqnState<B, M>;
  function forward (line 296) | fn forward(&mut self, states: Self::Observation) -> Self::ActionDistribu...
  function action (line 300) | fn action(
  function update (line 329) | fn update(&mut self, update: Self::PolicyState) {
  function state (line 333) | fn state(&self) -> Self::PolicyState {
  function load_record (line 340) | fn load_record(self, record: <Self::PolicyState as PolicyState<B>>::Reco...
  type DqnLearningRecord (line 350) | pub struct DqnLearningRecord<B: AutodiffBackend, M: AutodiffModule<B>, O...
  type DqnLearningAgent (line 357) | pub struct DqnLearningAgent<B, M, O>
  function new (line 378) | pub fn new(model: M, optimizer: O, config: DqnAgentConfig) -> Self {
  type SimpleTrainOutput (line 396) | pub struct SimpleTrainOutput<B: Backend> {
  type ItemSync (line 401) | type ItemSync = SimpleTrainOutput<NdArray>;
  method sync (line 403) | fn sync(self) -> Self::ItemSync {
  function adapt (line 419) | fn adapt(&self) -> LossInput<B> {
  type TrainContext (line 432) | type TrainContext = SimpleTrainOutput<B>;
  type InnerPolicy (line 433) | type InnerPolicy = EpsilonGreedyPolicy<B, DQN<B, M>>;
  type Record (line 434) | type Record = DqnLearningRecord<B, M, O>;
  function train (line 436) | fn train(
  function policy (line 490) | fn policy(&self) -> Self::InnerPolicy {
  function update_policy (line 494) | fn update_policy(&mut self, update: Self::InnerPolicy) {
  function record (line 498) | fn record(&self) -> Self::Record {
  function load_record (line 506) | fn load_record(self, record: Self::Record) -> Self {

FILE: examples/dqn-agent/src/env.rs
  type CartPoleAction (line 14) | pub struct CartPoleAction {
    method from (line 19) | fn from(value: DiscreteActionTensor<B, 2>) -> Self {
  function from (line 27) | fn from(value: CartPoleAction) -> Self {
  type CartPoleState (line 35) | pub struct CartPoleState {
    method from (line 40) | fn from(observation: CartPoleObservation) -> Self {
  function from (line 48) | fn from(val: CartPoleState) -> Self {
  type CartPoleWrapper (line 56) | pub struct CartPoleWrapper {
    method new (line 68) | pub fn new() -> Self {
  method default (line 62) | fn default() -> Self {
  type State (line 77) | type State = CartPoleState;
  type Action (line 78) | type Action = CartPoleAction;
  constant MAX_STEPS (line 80) | const MAX_STEPS: usize = 500;
  method state (line 82) | fn state(&self) -> Self::State {
  method step (line 86) | fn step(&mut self, action: Self::Action) -> StepResult<Self::State> {
  method reset (line 97) | fn reset(&mut self) {

FILE: examples/dqn-agent/src/training.rs
  function run (line 19) | pub fn run<B: AutodiffBackend>(device: B::Device) {

FILE: examples/dqn-agent/src/utils.rs
  function create_lin_layers (line 21) | pub fn create_lin_layers<B: Backend>(
  function soft_update_linear (line 46) | pub fn soft_update_linear<B: Backend>(this: Linear<B>, that: &Linear<B>,...
  function soft_update_tensor (line 56) | fn soft_update_tensor<const N: usize, B: Backend>(
  type EpsilonGreedyPolicyOutput (line 69) | pub struct EpsilonGreedyPolicyOutput {
    method adapt (line 82) | fn adapt(&self) -> ExplorationRateInput {
  type ItemSync (line 74) | type ItemSync = EpsilonGreedyPolicyOutput;
  method sync (line 76) | fn sync(self) -> Self::ItemSync {
  type EpsilonGreedyPolicyRecord (line 88) | pub struct EpsilonGreedyPolicyRecord<B: Backend, P: Policy<B>> {
  type EpsilonGreedyPolicyState (line 94) | pub struct EpsilonGreedyPolicyState<B: Backend, P: Policy<B>> {
  type Record (line 100) | type Record = EpsilonGreedyPolicyRecord<B, P>;
  function into_record (line 102) | fn into_record(self) -> Self::Record {
  function load_record (line 109) | fn load_record(&self, record: Self::Record) -> Self {
  type EpsilonGreedyPolicy (line 119) | pub struct EpsilonGreedyPolicy<B: Backend, P: Policy<B>> {
  function new (line 129) | pub fn new(inner_policy: P, eps_start: f64, eps_end: f64, eps_decay: f64...
  function get_threshold (line 140) | fn get_threshold(&self) -> f64 {
  function step (line 145) | fn step(&mut self) -> f64 {
  type ActionContext (line 161) | type ActionContext = EpsilonGreedyPolicyOutput;
  type PolicyState (line 162) | type PolicyState = EpsilonGreedyPolicyState<B, P>;
  type Observation (line 164) | type Observation = P::Observation;
  type ActionDistribution (line 165) | type ActionDistribution = DiscreteLogitsTensor<B, 2>;
  type Action (line 166) | type Action = DiscreteActionTensor<B, 2>;
  function forward (line 168) | fn forward(&mut self, states: Self::Observation) -> Self::ActionDistribu...
  function action (line 172) | fn action(
  function update (line 200) | fn update(&mut self, update: Self::PolicyState) {
  function state (line 205) | fn state(&self) -> Self::PolicyState {
  function load_record (line 212) | fn load_record(self, record: <Self::PolicyState as PolicyState<B>>::Reco...

FILE: examples/guide/examples/guide.rs
  function main (line 11) | fn main() {

FILE: examples/guide/src/bin/infer.rs
  function main (line 5) | fn main() {

FILE: examples/guide/src/bin/print.rs
  function main (line 4) | fn main() {

FILE: examples/guide/src/bin/train.rs
  function main (line 13) | fn main() {

FILE: examples/guide/src/data.rs
  type MnistBatcher (line 7) | pub struct MnistBatcher {}
    method batch (line 16) | fn batch(&self, items: Vec<MnistItem>, device: &B::Device) -> MnistBat...
  type MnistBatch (line 10) | pub struct MnistBatch<B: Backend> {

FILE: examples/guide/src/inference.rs
  function infer (line 8) | pub fn infer<B: Backend>(artifact_dir: &str, device: B::Device, item: Mn...

FILE: examples/guide/src/model.rs
  type Model (line 11) | pub struct Model<B: Backend> {
  type ModelConfig (line 22) | pub struct ModelConfig {
    method init (line 31) | pub fn init<B: Backend>(&self, device: &B::Device) -> Model<B> {
  function forward (line 48) | pub fn forward(&self, images: Tensor<B, 3>) -> Tensor<B, 2> {

FILE: examples/guide/src/training.rs
  function forward_classification (line 19) | pub fn forward_classification(
  type Input (line 34) | type Input = MnistBatch<B>;
  type Output (line 35) | type Output = ClassificationOutput<B>;
  method step (line 37) | fn step(&self, batch: MnistBatch<B>) -> TrainOutput<ClassificationOutput...
  type Input (line 45) | type Input = MnistBatch<B>;
  type Output (line 46) | type Output = ClassificationOutput<B>;
  method step (line 48) | fn step(&self, batch: MnistBatch<B>) -> ClassificationOutput<B> {
  type TrainingConfig (line 54) | pub struct TrainingConfig {
  function create_artifact_dir (line 69) | fn create_artifact_dir(artifact_dir: &str) {
  function train (line 75) | pub fn train<B: AutodiffBackend>(artifact_dir: &str, config: TrainingCon...

FILE: examples/import-model-weights/src/bin/burnpack.rs
  type B (line 9) | type B = NdArray<f32>;
  function main (line 11) | pub fn main() {

FILE: examples/import-model-weights/src/bin/convert.rs
  constant PYTORCH_WEIGHTS_PATH (line 10) | const PYTORCH_WEIGHTS_PATH: &str = "weights/mnist.pt";
  constant SAFETENSORS_WEIGHTS_PATH (line 11) | const SAFETENSORS_WEIGHTS_PATH: &str = "weights/mnist.safetensors";
  constant MODEL_OUTPUT_NAME (line 12) | const MODEL_OUTPUT_NAME: &str = "mnist";
  type B (line 15) | type B = NdArray<f32>;
  function main (line 17) | pub fn main() {

FILE: examples/import-model-weights/src/bin/pytorch.rs
  type B (line 7) | type B = NdArray<f32>;
  constant WEIGHTS_FILE (line 9) | const WEIGHTS_FILE: &str = "weights/mnist.pt";
  function main (line 11) | pub fn main() {

FILE: examples/import-model-weights/src/bin/safetensors.rs
  type B (line 7) | type B = NdArray<f32>;
  constant WEIGHTS_FILE (line 9) | const WEIGHTS_FILE: &str = "weights/mnist.safetensors";
  function main (line 11) | pub fn main() {

FILE: examples/import-model-weights/src/inference.rs
  constant IMAGE_INX (line 10) | const IMAGE_INX: usize = 42;
  function infer (line 12) | pub fn infer<B: Backend>(model: Model<B>) {

FILE: examples/import-model-weights/src/model.rs
  type Model (line 11) | pub struct Model<B: Backend> {
  function init (line 22) | pub fn init(device: &B::Device) -> Self {
  function forward (line 42) | pub fn forward(&self, input1: Tensor<B, 4>) -> Tensor<B, 2> {

FILE: examples/import-model-weights/weights/mnist_train_export.py
  class Net (line 17) | class Net(nn.Module):
    method __init__ (line 18) | def __init__(self):
    method forward (line 29) | def forward(self, x):
  function train (line 47) | def train(args, model, device, train_loader, optimizer, epoch):
  function test (line 70) | def test(model, device, test_loader):
  function main (line 96) | def main():

FILE: examples/mnist-inference-web/index.js
  function cropScaleGetImageData (line 17) | function cropScaleGetImageData(mainContext, cropContext, scaledContext) {
  function rgba2gray (line 51) | function rgba2gray(data) {
  function cropImageFromCanvas (line 73) | function cropImageFromCanvas(ctx) {
  function toFixed (line 114) | function toFixed(num, fixed) {
  function $ (line 123) | function $(id) {
  function chartConfigBuilder (line 133) | function chartConfigBuilder(chartEl) {

FILE: examples/mnist-inference-web/src/model.rs
  type Model (line 10) | pub struct Model<B: Backend> {
  constant NUM_CLASSES (line 20) | const NUM_CLASSES: usize = 10;
  function new (line 23) | pub fn new(device: &B::Device) -> Self {
  function forward (line 44) | pub fn forward(&self, input: Tensor<B, 3>) -> Tensor<B, 2> {
  type ConvBlock (line 66) | pub struct ConvBlock<B: Backend> {
  function new (line 74) | pub fn new(
  function forward (line 98) | pub fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {

FILE: examples/mnist-inference-web/src/state.rs
  type Backend (line 11) | pub type Backend = Wgpu<f32, i32>;
  type Backend (line 14) | pub type Backend = burn::backend::ndarray::NdArray<f32>;
  function build_and_load_model (line 19) | pub async fn build_and_load_model() -> Model<Backend> {

FILE: examples/mnist-inference-web/src/web.rs
  function start (line 15) | pub fn start() {
  type Mnist (line 22) | pub struct Mnist {
    method new (line 30) | pub fn new() -> Self {
    method inference (line 47) | pub async fn inference(&mut self, input: &[f32]) -> Result<Array, Stri...

FILE: examples/mnist/examples/mnist.rs
  function select_device (line 18) | fn select_device() -> DispatchDevice {
  function main (line 43) | fn main() {

FILE: examples/mnist/src/data.rs
  type MnistBatcher (line 15) | pub struct MnistBatcher {}
    method batch (line 24) | fn batch(&self, items: Vec<MnistItemPrepared>, device: &B::Device) -> ...
  type MnistBatch (line 18) | pub struct MnistBatch<B: Backend> {
  type Transform (line 48) | pub enum Transform {
  method fmt (line 56) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type MnistMapper (line 67) | pub struct MnistMapper {
    method transform (line 72) | pub fn transform(mut self, transforms: &[Transform]) -> Self {
    method translate (line 78) | pub fn translate(mut self) -> Self {
    method shear (line 82) | pub fn shear(mut self) -> Self {
    method scale (line 86) | pub fn scale(mut self) -> Self {
    method rotation (line 90) | pub fn rotation(mut self) -> Self {
    method map (line 97) | fn map(&self, item: &MnistItem) -> MnistItemPrepared {
  type MnistItemPrepared (line 103) | pub struct MnistItemPrepared {
  function prepare_image (line 108) | fn prepare_image(transforms: &[Transform], item: MnistItem) -> MnistItem...
  function mangle_image_batch (line 136) | fn mangle_image_batch<B: Backend>(transforms: &[Transform], images: Tens...

FILE: examples/mnist/src/model.rs
  type Model (line 14) | pub struct Model<B: Backend> {
  method default (line 25) | fn default() -> Self {
  constant NUM_CLASSES (line 31) | const NUM_CLASSES: usize = 10;
  function new (line 34) | pub fn new(device: &B::Device) -> Self {
  function forward (line 55) | pub fn forward(&self, input: Tensor<B, 3>) -> Tensor<B, 2> {
  function forward_classification (line 76) | pub fn forward_classification(&self, item: MnistBatch<B>) -> Classificat...
  type ConvBlock (line 92) | pub struct ConvBlock<B: Backend> {
  function new (line 100) | pub fn new(
  function forward (line 124) | pub fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
  type Input (line 138) | type Input = MnistBatch<B>;
  type Output (line 139) | type Output = ClassificationOutput<B>;
  method step (line 141) | fn step(&self, item: MnistBatch<B>) -> TrainOutput<ClassificationOutput<...
  type Input (line 149) | type Input = MnistBatch<B>;
  type Output (line 150) | type Output = ClassificationOutput<B>;
  method step (line 152) | fn step(&self, item: MnistBatch<B>) -> ClassificationOutput<B> {

FILE: examples/mnist/src/training.rs
  type MnistTrainingConfig (line 38) | pub struct MnistTrainingConfig {
  function create_artifact_dir (line 54) | fn create_artifact_dir(artifact_dir: &str) {
  function run (line 60) | pub fn run<B: AutodiffBackend>(device: B::Device) {
  function evaluate (line 149) | fn evaluate<B: Backend>(
  type DatasetIdent (line 173) | enum DatasetIdent {
    method fmt (line 180) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method many (line 199) | pub fn many(transforms: Vec<Transform>) -> Self {
    method prepare (line 203) | pub fn prepare(self, dataset: impl Dataset<MnistItem>) -> impl Dataset...
    method compose (line 219) | pub fn compose(
  function generate_idents (line 240) | fn generate_idents(num_samples_base: Option<usize>) -> Vec<(DatasetIdent...

FILE: examples/modern-lstm/examples/lstm-infer.rs
  function launch (line 3) | pub fn launch<B: Backend>(device: B::Device) {
  function run (line 18) | pub fn run() {
  function run (line 29) | pub fn run() {
  function run (line 45) | pub fn run() {
  function run (line 55) | pub fn run() {
  function run (line 65) | pub fn run() {
  function main (line 70) | fn main() {

FILE: examples/modern-lstm/examples/lstm-train.rs
  function launch (line 6) | pub fn launch<B: AutodiffBackend>(device: B::Device) {
  function run (line 30) | pub fn run() {
  function run (line 44) | pub fn run() {
  function run (line 63) | pub fn run() {
  function run (line 73) | pub fn run() {
  function run (line 83) | pub fn run() {
  function main (line 88) | fn main() {

FILE: examples/modern-lstm/src/dataset.rs
  constant NUM_SEQUENCES (line 13) | pub const NUM_SEQUENCES: usize = 1000;
  constant SEQ_LENGTH (line 14) | pub const SEQ_LENGTH: usize = 10;
  constant NOISE_LEVEL (line 15) | pub const NOISE_LEVEL: f32 = 0.1;
  constant RANDOM_SEED (line 16) | pub const RANDOM_SEED: u64 = 5;
  type SequenceDatasetItem (line 20) | pub struct SequenceDatasetItem {
    method new (line 26) | pub fn new(seq_length: usize, noise_level: f32) -> Self {
  type SequenceDataset (line 48) | pub struct SequenceDataset {
    method new (line 53) | pub fn new(num_sequences: usize, seq_length: usize, noise_level: f32) ...
    method get (line 65) | fn get(&self, index: usize) -> Option<SequenceDatasetItem> {
    method len (line 69) | fn len(&self) -> usize {
  type SequenceBatcher (line 75) | pub struct SequenceBatcher {}
    method batch (line 84) | fn batch(&self, items: Vec<SequenceDatasetItem>, device: &B::Device) -...
  type SequenceBatch (line 78) | pub struct SequenceBatch<B: Backend> {

FILE: examples/modern-lstm/src/inference.rs
  function infer (line 16) | pub fn infer<B: Backend>(artifact_dir: &str, device: B::Device) {

FILE: examples/modern-lstm/src/model.rs
  type LstmCell (line 26) | pub struct LstmCell<B: Backend> {
  type LstmCellConfig (line 42) | pub struct LstmCellConfig {
    method init (line 56) | pub fn init<B: Backend>(&self, device: &B::Device) -> LstmCell<B> {
  function forward (line 102) | pub fn forward(&self, x: Tensor<B, 2>, state: LstmState<B, 2>) -> LstmSt...
  function init_state (line 143) | pub fn init_state(&self, batch_size: usize, device: &B::Device) -> LstmS...
  type StackedLstm (line 154) | pub struct StackedLstm<B: Backend> {
  type StackedLstmConfig (line 159) | pub struct StackedLstmConfig {
    method init (line 167) | pub fn init<B: Backend>(&self, device: &B::Device) -> StackedLstm<B> {
  function forward (line 209) | pub fn forward(
  type LstmNetwork (line 255) | pub struct LstmNetwork<B: Backend> {
  type LstmNetworkConfig (line 265) | pub struct LstmNetworkConfig {
    method init (line 281) | pub fn init<B: Backend>(&self, device: &B::Device) -> LstmNetwork<B> {
  function forward (line 332) | pub fn forward(&self, x: Tensor<B, 3>, states: Option<Vec<LstmState<B, 2...

FILE: examples/modern-lstm/src/training.rs
  type TrainingConfig (line 16) | pub struct TrainingConfig {
  function create_artifact_dir (line 31) | fn create_artifact_dir(artifact_dir: &str) {
  function train (line 37) | pub fn train<B: AutodiffBackend>(artifact_dir: &str, config: TrainingCon...

FILE: examples/multi-gpus/examples/multi-gpus.rs
  function main (line 1) | fn main() {

FILE: examples/multi-gpus/src/lib.rs
  function run (line 23) | pub fn run<B: Backend>() {
  function run_with (line 34) | fn run_with<B: Backend>(devices: Vec<B::Device>) {
  function task_naive_aggregation (line 61) | fn task_naive_aggregation<B: Backend>(mut devices: Vec<B::Device>, num_i...
  function task_all_reduce (line 110) | fn task_all_reduce<B: Backend>(
  function task_grad_all_reduce (line 173) | fn task_grad_all_reduce<B: AutodiffBackend>(
  type GradSyncer (line 245) | struct GradSyncer {
    method start (line 255) | fn start<B: AutodiffBackend>(config: CollectiveConfig, device: Device<...
    method sync (line 286) | fn sync(&self, grads: GradientsParams) -> Option<GradientsParams> {
  type Message (line 249) | struct Message {

FILE: examples/server/examples/server.rs
  function main (line 1) | fn main() {

FILE: examples/server/src/lib.rs
  function start (line 3) | pub fn start() {

FILE: examples/simple-regression/examples/regression.rs
  function run (line 15) | pub fn run() {
  function run (line 25) | pub fn run() {
  function run (line 39) | pub fn run() {
  function run (line 49) | pub fn run() {
  function run (line 59) | pub fn run() {
  function run (line 66) | pub fn run<B: Backend>(device: B::Device) {
  function main (line 71) | fn main() {

FILE: examples/simple-regression/src/dataset.rs
  constant NUM_FEATURES (line 9) | pub const NUM_FEATURES: usize = 8;
  constant FEATURES_MIN (line 12) | const FEATURES_MIN: [f32; NUM_FEATURES] = [0.4999, 1., 0.8461, 0.375, 3....
  constant FEATURES_MAX (line 13) | const FEATURES_MAX: [f32; NUM_FEATURES] = [
  type HousingDistrictItem (line 18) | pub struct HousingDistrictItem {
  type HousingDataset (line 56) | pub struct HousingDataset {
    method get (line 61) | fn get(&self, index: usize) -> Option<HousingDistrictItem> {
    method len (line 65) | fn len(&self) -> usize {
    method train (line 71) | pub fn train() -> Self {
    method validation (line 75) | pub fn validation() -> Self {
    method test (line 79) | pub fn test() -> Self {
    method new (line 83) | pub fn new(split: &str) -> Self {
  type Normalizer (line 95) | pub struct Normalizer<B: Backend> {
  function new (line 102) | pub fn new(device: &B::Device, min: &[f32], max: &[f32]) -> Self {
  function normalize (line 109) | pub fn normalize(&self, input: Tensor<B, 2>) -> Tensor<B, 2> {
  function to_device (line 114) | pub fn to_device(&self, device: &B::Device) -> Self {
  type HousingBatcher (line 123) | pub struct HousingBatcher<B: Backend> {
  type HousingBatch (line 128) | pub struct HousingBatch<B: Backend> {
  function new (line 134) | pub fn new(device: B::Device) -> Self {
  function batch (line 142) | fn batch(&self, items: Vec<HousingDistrictItem>, device: &B::Device) -> ...

FILE: examples/simple-regression/src/inference.rs
  function infer (line 15) | pub fn infer<B: Backend>(artifact_dir: &str, device: B::Device) {

FILE: examples/simple-regression/src/model.rs
  type RegressionModel (line 13) | pub struct RegressionModel<B: Backend> {
  type RegressionModelConfig (line 20) | pub struct RegressionModelConfig {
    method init (line 26) | pub fn init<B: Backend>(&self, device: &B::Device) -> RegressionModel<...
  function forward (line 43) | pub fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2> {
  function forward_step (line 49) | pub fn forward_step(&self, item: HousingBatch<B>) -> RegressionOutput<B> {
  type Input (line 64) | type Input = HousingBatch<B>;
  type Output (line 65) | type Output = RegressionOutput<B>;
  method step (line 67) | fn step(&self, item: HousingBatch<B>) -> TrainOutput<RegressionOutput<B>> {
  type Input (line 75) | type Input = HousingBatch<B>;
  type Output (line 76) | type Output = RegressionOutput<B>;
  method step (line 78) | fn step(&self, item: HousingBatch<B>) -> RegressionOutput<B> {

FILE: examples/simple-regression/src/training.rs
  type ExpConfig (line 14) | pub struct ExpConfig {
  function create_artifact_dir (line 30) | fn create_artifact_dir(artifact_dir: &str) {
  function run (line 36) | pub fn run<B: AutodiffBackend>(artifact_dir: &str, device: B::Device) {

FILE: examples/text-classification/examples/ag-news-infer.rs
  type ElemType (line 8) | type ElemType = f32;
  type ElemType (line 10) | type ElemType = burn::tensor::f16;
  function launch (line 12) | pub fn launch<B: Backend>(device: B::Device) {
  function run (line 46) | pub fn run() {
  function run (line 56) | pub fn run() {
  function run (line 71) | pub fn run() {
  function run (line 81) | pub fn run() {
  function run (line 91) | pub fn run() {
  function run (line 101) | pub fn run() {
  function main (line 106) | fn main() {

FILE: examples/text-classification/examples/ag-news-train.rs
  type ElemType (line 14) | type ElemType = f32;
  type ElemType (line 16) | type ElemType = burn::tensor::f16;
  type ElemType (line 18) | type ElemType = burn::tensor::flex32;
  function launch_multi (line 20) | pub fn launch_multi<B: AutodiffBackend>() {
  function launch (line 31) | pub fn launch<B: AutodiffBackend>(devices: Vec<B::Device>) {
  function run (line 62) | pub fn run() {
  function run (line 76) | pub fn run() {
  function run (line 95) | pub fn run() {
  function run (line 105) | pub fn run() {
  function run (line 115) | pub fn run() {
  function run (line 126) | pub fn run() {
  function run (line 136) | pub fn run() {
  function run (line 146) | pub fn run() {
  function run (line 156) | pub fn run() {
  function main (line 161) | fn main() {

FILE: examples/text-classification/examples/db-pedia-infer.rs
  type ElemType (line 7) | type ElemType = f32;
  type ElemType (line 9) | type ElemType = burn::tensor::f16;
  function launch (line 11) | pub fn launch<B: Backend>(device: B::Device) {
  function run (line 41) | pub fn run() {
  function run (line 52) | pub fn run() {
  function run (line 68) | pub fn run() {
  function run (line 79) | pub fn run() {
  function main (line 84) | fn main() {

FILE: examples/text-classification/examples/db-pedia-train.rs
  type ElemType (line 11) | type ElemType = f32;
  type ElemType (line 13) | type ElemType = burn::tensor::f16;
  function launch (line 15) | pub fn launch<B: AutodiffBackend>(devices: Vec<B::Device>) {
  function run (line 43) | pub fn run() {
  function run (line 57) | pub fn run() {
  function run (line 76) | pub fn run() {
  function run (line 90) | pub fn run() {
  function main (line 95) | fn main() {

FILE: examples/text-classification/src/data/batcher.rs
  type TextClassificationBatcher (line 23) | pub struct TextClassificationBatcher {
    method batch (line 48) | fn batch(
    method batch (line 87) | fn batch(&self, items: Vec<String>, device: &B::Device) -> TextClassif...
  type TextClassificationTrainingBatch (line 30) | pub struct TextClassificationTrainingBatch<B: Backend> {
  type TextClassificationInferenceBatch (line 38) | pub struct TextClassificationInferenceBatch<B: Backend> {

FILE: examples/text-classification/src/data/dataset.rs
  type TextClassificationItem (line 12) | pub struct TextClassificationItem {
  type TextClassificationDataset (line 18) | pub trait TextClassificationDataset: Dataset<TextClassificationItem> {
    method num_classes (line 19) | fn num_classes() -> usize;
    method class_name (line 20) | fn class_name(label: usize) -> String;
    method num_classes (line 74) | fn num_classes() -> usize {
    method class_name (line 79) | fn class_name(label: usize) -> String {
    method num_classes (line 146) | fn num_classes() -> usize {
    method class_name (line 151) | fn class_name(label: usize) -> String {
  type AgNewsItem (line 25) | pub struct AgNewsItem {
  type AgNewsDataset (line 31) | pub struct AgNewsDataset {
    method get (line 38) | fn get(&self, index: usize) -> Option<TextClassificationItem> {
    method len (line 45) | fn len(&self) -> usize {
    method train (line 53) | pub fn train() -> Self {
    method test (line 58) | pub fn test() -> Self {
    method new (line 63) | pub fn new(split: &str) -> Self {
  type DbPediaItem (line 93) | pub struct DbPediaItem {
  type DbPediaDataset (line 100) | pub struct DbPediaDataset {
    method get (line 107) | fn get(&self, index: usize) -> Option<TextClassificationItem> {
    method len (line 117) | fn len(&self) -> usize {
    method train (line 125) | pub fn train() -> Self {
    method test (line 130) | pub fn test() -> Self {
    method new (line 135) | pub fn new(split: &str) -> Self {

FILE: examples/text-classification/src/data/tokenizer.rs
  type Tokenizer (line 9) | pub trait Tokenizer: Send + Sync {
    method encode (line 11) | fn encode(&self, value: &str) -> Vec<usize>;
    method decode (line 14) | fn decode(&self, tokens: &[usize]) -> String;
    method vocab_size (line 17) | fn vocab_size(&self) -> usize;
    method pad_token (line 20) | fn pad_token(&self) -> usize;
    method pad_token_value (line 24) | fn pad_token_value(&self) -> String {
    method encode (line 48) | fn encode(&self, value: &str) -> Vec<usize> {
    method decode (line 54) | fn decode(&self, tokens: &[usize]) -> String {
    method vocab_size (line 60) | fn vocab_size(&self) -> usize {
    method pad_token (line 65) | fn pad_token(&self) -> usize {
  type BertCasedTokenizer (line 30) | pub struct BertCasedTokenizer {
  method default (line 38) | fn default() -> Self {

FILE: examples/text-classification/src/inference.rs
  function infer (line 20) | pub fn infer<B: Backend, D: TextClassificationDataset + 'static>(

FILE: examples/text-classification/src/model.rs
  type TextClassificationModelConfig (line 21) | pub struct TextClassificationModelConfig {
    method init (line 41) | pub fn init<B: Backend>(&self, device: &B::Device) -> TextClassificati...
  type TextClassificationModel (line 30) | pub struct TextClassificationModel<B: Backend> {
  function forward (line 68) | pub fn forward(&self, item: TextClassificationTrainingBatch<B>) -> Class...
  function infer (line 109) | pub fn infer(&self, item: TextClassificationInferenceBatch<B>) -> Tensor...
  type Input (line 141) | type Input = TextClassificationTrainingBatch<B>;
  type Output (line 142) | type Output = ClassificationOutput<B>;
  method step (line 144) | fn step(
  type Input (line 158) | type Input = TextClassificationTrainingBatch<B>;
  type Output (line 159) | type Output = ClassificationOutput<B>;
  method step (line 161) | fn step(&self, item: TextClassificationTrainingBatch<B>) -> Classificati...

FILE: examples/text-classification/src/training.rs
  type ExperimentConfig (line 35) | pub struct ExperimentConfig {
  function train (line 47) | pub fn train<B: AutodiffBackend, D: TextClassificationDataset + 'static>(

FILE: examples/text-generation/examples/text-generation.rs
  type Elem (line 5) | type Elem = burn::tensor::f16;
  type Elem (line 7) | type Elem = f32;
  type Backend (line 9) | type Backend = burn::backend::Autodiff<burn::backend::LibTorch<Elem>>;
  function main (line 11) | fn main() {

FILE: examples/text-generation/src/data/batcher.rs
  type TextGenerationBatcher (line 6) | pub struct TextGenerationBatcher {
    method batch (line 25) | fn batch(&self, items: Vec<TextGenerationItem>, device: &B::Device) ->...
    method batch (line 49) | fn batch(
  type TextGenerationBatch (line 12) | pub struct TextGenerationBatch<B: Backend> {
  type TrainingTextGenerationBatch (line 18) | pub struct TrainingTextGenerationBatch<B: Backend> {

FILE: examples/text-generation/src/data/dataset.rs
  type TextGenerationItem (line 4) | pub struct TextGenerationItem {
  type DbPediaItem (line 9) | pub struct DbPediaItem {
  type DbPediaDataset (line 13) | pub struct DbPediaDataset {
    method get (line 18) | fn get(&self, index: usize) -> Option<TextGenerationItem> {
    method len (line 24) | fn len(&self) -> usize {
    method train (line 30) | pub fn train() -> Self {
    method test (line 34) | pub fn test() -> Self {
    method new (line 37) | pub fn new(split: &str) -> Self {

FILE: examples/text-generation/src/data/tokenizer.rs
  type Tokenizer (line 2) | pub trait Tokenizer: Send + Sync {
    method encode (line 3) | fn encode(&self, value: &str, special_tokens: bool) -> Vec<usize>;
    method decode (line 4) | fn decode(&self, tokens: &[usize]) -> String;
    method vocab_size (line 5) | fn vocab_size(&self) -> usize;
    method pad_token (line 6) | fn pad_token(&self) -> usize;
    method start_token (line 7) | fn start_token(&self) -> usize;
    method end_token (line 8) | fn end_token(&self) -> usize;
    method pad_token_value (line 9) | fn pad_token_value(&self) -> String {
    method start_token_value (line 12) | fn start_token_value(&self) -> String {
    method end_token_value (line 15) | fn end_token_value(&self) -> String {
    method encode (line 38) | fn encode(&self, value: &str, special_tokens: bool) -> Vec<usize> {
    method decode (line 47) | fn decode(&self, tokens: &[usize]) -> String {
    method vocab_size (line 52) | fn vocab_size(&self) -> usize {
    method pad_token (line 56) | fn pad_token(&self) -> usize {
    method start_token (line 60) | fn start_token(&self) -> usize {
    method end_token (line 64) | fn end_token(&self) -> usize {
  type Gpt2Tokenizer (line 20) | pub struct Gpt2Tokenizer {
  method default (line 25) | fn default() -> Self {
  function test_encode_decode (line 74) | fn test_encode_decode() {
  function test_add_start_end_token (line 85) | fn test_add_start_end_token() {

FILE: examples/text-generation/src/model.rs
  type TextGenerationModelConfig (line 15) | pub struct TextGenerationModelConfig {
    method init (line 34) | pub fn init<B: Backend>(&self, device: &B::Device) -> TextGenerationMo...
  type TextGenerationModel (line 23) | pub struct TextGenerationModel<B: Backend> {
  function forward_training (line 54) | pub fn forward_training(
  type Input (line 98) | type Input = TrainingTextGenerationBatch<B>;
  type Output (line 99) | type Output = ClassificationOutput<B>;
  method step (line 101) | fn step(&self, item: TrainingTextGenerationBatch<B>) -> TrainOutput<Clas...
  type Input (line 110) | type Input = TrainingTextGenerationBatch<B>;
  type Output (line 111) | type Output = ClassificationOutput<B>;
  method step (line 113) | fn step(&self, item: TrainingTextGenerationBatch<B>) -> ClassificationOu...

FILE: examples/text-generation/src/training.rs
  type ExperimentConfig (line 24) | pub struct ExperimentConfig {
  function train (line 35) | pub fn train<B: AutodiffBackend, D: Dataset<TextGenerationItem> + 'static>(

FILE: examples/wgan/examples/wgan-generate.rs
  function launch (line 3) | pub fn launch<B: Backend>(device: B::Device) {
  function run (line 18) | pub fn run() {
  function run (line 29) | pub fn run() {
  function run (line 45) | pub fn run() {
  function run (line 55) | pub fn run() {
  function run (line 65) | pub fn run() {
  function main (line 70) | fn main() {

FILE: examples/wgan/examples/wgan-mnist.rs
  function launch (line 5) | pub fn launch<B: AutodiffBackend>(device: B::Device) {
  function run (line 33) | pub fn run() {
  function run (line 47) | pub fn run() {
  function run (line 66) | pub fn run() {
  function run (line 76) | pub fn run() {
  function run (line 86) | pub fn run() {
  function main (line 91) | fn main() {

FILE: examples/wgan/src/dataset.rs
  type MnistBatcher (line 7) | pub struct MnistBatcher {}
    method batch (line 16) | fn batch(&self, items: Vec<MnistItem>, device: &B::Device) -> MnistBat...
  type MnistBatch (line 10) | pub struct MnistBatch<B: Backend> {

FILE: examples/wgan/src/infer.rs
  function generate (line 8) | pub fn generate<B: Backend>(artifact_dir: &str, device: B::Device) {

FILE: examples/wgan/src/model.rs
  type LayerBlock (line 9) | pub struct LayerBlock<B: Backend> {
  function new (line 16) | pub fn new(input: usize, output: usize, device: &B::Device) -> Self {
  function forward (line 28) | pub fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2> {
  type Generator (line 38) | pub struct Generator<B: Backend> {
  function forward (line 49) | pub fn forward(&self, noise: Tensor<B, 2>) -> Tensor<B, 2> {
  type Discriminator (line 62) | pub struct Discriminator<B: Backend> {
  function forward (line 73) | pub fn forward(&self, images: Tensor<B, 4>) -> Tensor<B, 2> {
  type ModelConfig (line 87) | pub struct ModelConfig {
    method init (line 99) | pub fn init<B: Backend>(&self, device: &B::Device) -> (Generator<B>, D...
  type Clip (line 140) | pub struct Clip {
    method map_float (line 146) | fn map_float<const D: usize>(&mut self, param: Param<Tensor<B, D>>) ->...

FILE: examples/wgan/src/training.rs
  type TrainingConfig (line 14) | pub struct TrainingConfig {
  function create_artifact_dir (line 41) | fn create_artifact_dir(artifact_dir: &str) {
  function save_image (line 49) | pub fn save_image<B: Backend, Q: AsRef<Path>>(
  function train (line 92) | pub fn train<B: AutodiffBackend>(artifact_dir: &str, config: TrainingCon...

FILE: xtask/src/commands/books.rs
  type BooksArgs (line 6) | pub struct BooksArgs {
    method parse (line 47) | pub(crate) fn parse(&self) -> anyhow::Result<()> {
  type BookKind (line 12) | pub(crate) enum BookKind {
  type BookKindArgs (line 20) | pub(crate) struct BookKindArgs {
  type BookSubCommand (line 26) | pub(crate) enum BookSubCommand {
  type OpenArgs (line 34) | pub(crate) struct OpenArgs {
  type Book (line 41) | pub(crate) struct Book {
    constant BURN_BOOK_NAME (line 53) | const BURN_BOOK_NAME: &'static str = "Burn Book";
    constant BURN_BOOK_PATH (line 54) | const BURN_BOOK_PATH: &'static str = "./burn-book";
    constant CONTRIBUTOR_BOOK_NAME (line 56) | const CONTRIBUTOR_BOOK_NAME: &'static str = "Contributor Book";
    constant CONTRIBUTOR_BOOK_PATH (line 57) | const CONTRIBUTOR_BOOK_PATH: &'static str = "./contributor-book";
    method run (line 59) | pub(crate) fn run(book_arg: &BookKind) -> anyhow::Result<()> {
    method execute (line 79) | fn execute(&self, command: &BookSubCommand) -> anyhow::Result<()> {
    method build (line 90) | fn build(&self) -> anyhow::Result<()> {
    method open (line 100) | fn open(&self, args: &OpenArgs) -> anyhow::Result<()> {

FILE: xtask/src/commands/build.rs
  type BurnBuildCmdArgs (line 8) | pub struct BurnBuildCmdArgs {
  function handle_command (line 14) | pub(crate) fn handle_command(

FILE: xtask/src/commands/doc.rs
  function handle_command (line 3) | pub(crate) fn handle_command(

FILE: xtask/src/commands/test.rs
  type BurnTestCmdArgs (line 15) | pub struct BurnTestCmdArgs {
  type CiTestType (line 23) | pub enum CiTestType {
  function handle_backend_tests (line 31) | fn handle_backend_tests(
  function handle_wgpu_test (line 50) | fn handle_wgpu_test(member: &str, args: &TestCmdArgs) -> anyhow::Result<...
  function handle_command (line 83) | pub(crate) fn handle_command(
  function handle_test_args (line 320) | fn handle_test_args<'a>(args: &'a [&'a str], release: bool) -> Vec<&'a s...

FILE: xtask/src/commands/validate.rs
  function handle_command (line 8) | pub fn handle_command(

FILE: xtask/src/main.rs
  constant WASM32_TARGET (line 10) | const WASM32_TARGET: &str = "wasm32-unknown-unknown";
  constant ARM_TARGET (line 11) | const ARM_TARGET: &str = "thumbv7m-none-eabi";
  constant ARM_NO_ATOMIC_PTR_TARGET (line 12) | const ARM_NO_ATOMIC_PTR_TARGET: &str = "thumbv6m-none-eabi";
  constant NO_STD_CRATES (line 13) | const NO_STD_CRATES: &[&str] = &[
  type Command (line 36) | pub enum Command {
  function main (line 45) | fn main() -> anyhow::Result<()> {