Burn

https://docs.rs/burn/latest/
Admin
Burn is a comprehensive dynamic Deep Learning Framework built using Rust, designed for extreme...
Tokens:1,542,340
Snippets:14,074
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Interpolate2d Example

Source: https://docs.rs/burn/latest/burn/nn/interpolate/struct.Interpolate2d

This example demonstrates how to initialize and use the Interpolate2d module for resizing input tensors.

```APIDOC
## Interpolate2d Example

This example demonstrates how to initialize and use the Interpolate2d module for resizing input tensors.

```rust
let input = Tensor::<Backend, 2>::random([1, 3, 64, 64], Distribution::Uniform(0.0, 1.0), &device);
let interpolate = Interpolate2dConfig::new()
    .with_output_size(Some([128, 128]))
    .init();
let output = interpolate.forward(input);
assert_eq!(output.dims(), [1, 3, 128, 128]);
```
```

--------------------------------

### Example: Customizing Visitor and Lifetime Parameters

Source: https://docs.rs/burn/latest/burn/serde/macro.forward_to_deserialize_any

This example shows how to use `forward_to_deserialize_any!` with custom type parameters for the `Visitor` and lifetime, deviating from the default `'de` and `V`.

```rust
forward_to_deserialize_any! {
    <W: Visitor<'q>>
    bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
    bytes byte_buf option unit unit_struct newtype_struct seq tuple
    tuple_struct map struct enum identifier ignored_any
}
```

--------------------------------

### Visitor Trait Example

Source: https://docs.rs/burn/latest/burn/serde/de/trait.Visitor

An example implementation of the Visitor trait for deserializing a string that meets a minimum byte length requirement.

```APIDOC
## Visitor Trait Example

This example demonstrates how to implement the `Visitor` trait to deserialize a string with a minimum length constraint.

### Struct Definition
```rust
/// A visitor that deserializes a long string - a string containing at least
/// some minimum number of bytes.
struct LongString {
    min: usize,
}
```

### Implementation
```rust
impl<'de> Visitor<'de> for LongString {
    type Value = String;

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        write!(formatter, "a string containing at least {} bytes", self.min)
    }

    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        if s.len() >= self.min {
            Ok(s.to_owned())
        } else {
            Err(de::Error::invalid_value(Unexpected::Str(s), &self))
        }
    }
}
```
```

--------------------------------

### Example: Forwarding deserialize_bool

Source: https://docs.rs/burn/latest/burn/serde/macro.forward_to_deserialize_any

A concrete example of implementing `deserialize_bool` by forwarding to `deserialize_any`. This pattern is used when the deserializer can infer the data type.

```rust
#[inline]
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
    V: Visitor<'de>,
{
    self.deserialize_any(visitor)
}
```

--------------------------------

### Pad Tensor Example

Source: https://docs.rs/burn/latest/burn/prelude/struct.Tensor

Demonstrates how to pad a tensor with a specified value. The padding is applied to all dimensions.

```rust
use burn_tensor::backend::Backend;
use burn_tensor::{Tensor, Shape};

fn example<B: Backend<FloatElem: From<f32>>>() {
   let device = B::Device::default();
   let tensor = Tensor::<B, 2>::from_data([[12.0, -2.0, 3.0], [5.0, 3.0, 6.0]], &device);
   let tensor = tensor.pad((1, 1, 1, 1), 0.0);
   println!("{tensor}");
   // [
   //   [0.0, 0.0, 0.0, 0.0, 0.0],
   //   [0.0, 12.0, -2.0, 3.0, 0.0],
   //   [0.0, 5.0, 3.0, 6.0, 0.0],
   //   [0.0, 0.0, 0.0, 0.0, 0.0]
   // ]
}
```

--------------------------------

### Unsafe Get Disjoint Mutable References (RangeInclusive and usize indices)

Source: https://docs.rs/burn/latest/burn/tensor/struct.Bytes

This example demonstrates using a mix of `RangeInclusive` and `usize` indices to get mutable references. Note that the method expects all indices in the input array to be of the same type. This example is illustrative of the types of indices supported but would require separate calls if types differ.

```rust
let x = &mut [1, 2, 4];

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([1..=2, 0..=0]);
    a[0] = 11;
    a[1] = 111;
    b[0] = 1;
}
assert_eq!(x, &[1, 11, 111]);
```

--------------------------------

### Module Initialization and Loading Example

Source: https://docs.rs/burn/latest/burn/module/struct.Param

Demonstrates initializing a module with a configuration and then loading a record, potentially reusing allocated tensors if the device matches.

```rust
let device = Device::default();
let config = ModuleConfig::default();
let record = Recorder::new().load("/path/to/module", &device);

// No tensor allocation
let module = config.init(device);
// Will use the tensor allocated for the record if the same device is used.
let module = module.load_record(record);

```

--------------------------------

### Tensor Indexing

Source: https://docs.rs/burn/latest/burn/prelude/struct.Tensor

Demonstrates how to index into a Tensor. This section includes a practical example of tensor indexing.

```APIDOC
## Tensor

### Indexing

This section covers how to access elements within a Tensor using indexing. It provides an example to illustrate the usage.

#### Example

```rust
// Example code for tensor indexing would go here
```
```

--------------------------------

### Rust splitn example

Source: https://docs.rs/burn/latest/burn/tensor/struct.Bytes

Demonstrates splitting a slice using `splitn` to get a maximum number of subslices based on a predicate. The last subslice contains the remainder.

```rust
let v = [10, 40, 30, 20, 60, 50];

for group in v.splitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}
```

--------------------------------

### InstanceNormConfig::init

Source: https://docs.rs/burn/latest/burn/nn/struct.InstanceNormConfig

Initializes a new InstanceNorm module with the given device.

```APIDOC
## InstanceNormConfig::init<B>

### Description
Initialize a new instance norm module.

### Method
`init`

### Parameters
- `device`: The device on which to initialize the module.

### Returns
- `InstanceNorm<B>`: An initialized InstanceNorm module.
```

--------------------------------

### CompactRecorder::new

Source: https://docs.rs/burn/latest/burn/record/type.CompactRecorder

Creates a new instance of CompactRecorder. This is the primary way to initialize a CompactRecorder for use.

```APIDOC
## method new

Creates a new instance of `CompactRecorder`.

### Signature

```rust
pub fn new() -> CompactRecorder
```

### Returns

A new `CompactRecorder` instance.
```

--------------------------------

### Tensor Top-K with Indices Example

Source: https://docs.rs/burn/latest/burn/prelude/struct.Tensor

Shows how to get the k largest elements and their corresponding indices from a tensor along a given dimension. Requires importing Backend, Tensor, and Shape.

```rust
use burn_tensor::backend::Backend;
use burn_tensor::{Tensor, Shape};

fn example<B: Backend>() {
   let device = B::Device::default();
   let tensor = Tensor::<B, 2>::from_data([[12.0, -2.0, 3.0], [5.0, 3.0, 6.0]], &device);
   let (tensor, indices) = tensor.topk_with_indices(2, 0);
   println!("{tensor}");
   // [[12.0, 3.0, 6.0], [5.0, -2.0, 3.0]]
   println!("{}", indices);
   // [[0, 1, 1], [1, 0, 0]]
   let (tensor, indices) = tensor.topk_with_indices(1, 1);
   println!("{tensor}");
   // [[12.0], [6.0]]
   println!("{indices}");
   // [[0], [2]]
}
```

--------------------------------

### Iterate subslices from the end with rsplitn

Source: https://docs.rs/burn/latest/burn/tensor/struct.Bytes

Use `rsplitn` to get an iterator over subslices separated by elements matching a predicate, starting from the end. Limited to `n` items, the last item contains the remainder.

```rust
let v = [10, 40, 30, 20, 60, 50];

for group in v.rsplitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}
```

--------------------------------

### DisplaySettings::new

Source: https://docs.rs/burn/latest/burn/module/struct.DisplaySettings

Creates a new instance of DisplaySettings with default settings.

```APIDOC
## DisplaySettings::new

### Description
Create a new format settings.

### Method
```
pub fn new() -> DisplaySettings
```

### Returns
A new instance of `DisplaySettings`.
```

--------------------------------

### init

Source: https://docs.rs/burn/latest/burn/nn/attention/struct.MultiHeadAttentionConfig

Initializes a new MultiHeadAttention module on the specified device.

```APIDOC
## init

### Description
Initialize a new multihead attention module.

### Method
`init<B>(&self, device: &<B as Backend>::Device) -> MultiHeadAttention<B>`

### Type Parameters
- **B**: A type implementing the `Backend` trait.

### Parameters
- **device** (&<B as Backend>::Device) - The device on which to initialize the module.
```

--------------------------------

### Iterate Over Slice in Exact Chunks from the End (Immutable)

Source: https://docs.rs/burn/latest/burn/tensor/struct.Bytes

Use `rchunks_exact` to get an iterator over immutable slices of a fixed size, starting from the end. The last elements might be omitted if they don't form a full chunk; use `remainder()` to access them. Panics if `chunk_size` is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks_exact(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &['l']);
```

--------------------------------

### Iterate Over Slice in Exact Chunks from the End (Mutable)

Source: https://docs.rs/burn/latest/burn/tensor/struct.Bytes

Use `rchunks_exact_mut` to get an iterator over mutable slices of a fixed size, starting from the end. This allows in-place modification of slice elements within each chunk. The last elements might be omitted if they don't form a full chunk; use `into_remainder()` to access them. Panics if `chunk_size` is zero.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_exact_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[0, 2, 2, 1, 1]);
```

--------------------------------

### InstanceNormConfig::load

Source: https://docs.rs/burn/latest/burn/nn/struct.InstanceNormConfig

Loads the configuration from a file.

```APIDOC
## InstanceNormConfig::load

### Description
Loads the configuration from a file.

### Method
`load`

### Parameters
- `file`: The path to the file from which the configuration will be loaded.

### Returns
- `Result<InstanceNormConfig, ConfigError>`: Ok(InstanceNormConfig) if loading is successful, or a ConfigError if it fails.
```

--------------------------------

### init Method

Source: https://docs.rs/burn/latest/burn/nn/struct.RmsNormConfig

Initializes a RmsNormConfig with the given initializer.

```APIDOC
## init

### Description
Initializes a with the given initializer.

### Signature
`unsafe fn init(init: <T as Pointable>::Init) -> usize`

### Parameters
* `init` - The initializer value.
```

--------------------------------

### Example: Implementing Deserializer with forward_to_deserialize_any!

Source: https://docs.rs/burn/latest/burn/serde/macro.forward_to_deserialize_any

This snippet demonstrates how to use the `forward_to_deserialize_any!` macro within an `impl` block for a custom `Deserializer`. It forwards a list of data types to `deserialize_any`.

```rust
impl<'de> Deserializer<'de> for MyDeserializer {
    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        /* ... */
    }

    forward_to_deserialize_any! {
        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
        bytes byte_buf option unit unit_struct newtype_struct seq tuple
        tuple_struct map struct enum identifier ignored_any
    }
}
```

--------------------------------

### Serializer Implementation Example

Source: https://docs.rs/burn/latest/burn/serde/ser/struct.Impossible

An example demonstrating how a custom serializer might use the Impossible struct to indicate that it does not support serializing sequences.

```APIDOC
### Example Usage
```rust
impl Serializer for MySerializer {
    type Ok = ();
    type Error = Error;

    type SerializeSeq = Impossible<(), Error>;
    /* other associated types */

    /// This data format does not support serializing sequences.
    fn serialize_seq(self,
                     len: Option<usize>)
                     -> Result<Self::SerializeSeq, Error> {
        // Given Impossible cannot be instantiated, the only
        // thing we can do here is to return an error.
        Err(...)
    }

    /* other Serializer methods */
}
```
```

--------------------------------

### GruConfig::init

Source: https://docs.rs/burn/latest/burn/nn/gru/struct.GruConfig

Initializes a new GRU module on the specified device.

```APIDOC
## GruConfig::init

### Description
Initialize a new gru module.

### Method
`init<B>(&self, device: &<B as Backend>::Device) -> Gru<B>`

### Parameters
- **device** (&<B as Backend>::Device) - The device on which to initialize the GRU module.

### Type Parameters
- **B**: Must implement the `Backend` trait.
```

--------------------------------

### NoStdTrainingRecorder::new

Source: https://docs.rs/burn/latest/burn/record/type.NoStdTrainingRecorder

Creates a new instance of NoStdTrainingRecorder.

```APIDOC
## NoStdTrainingRecorder::new

### Description
Creates a new instance of `NoStdTrainingRecorder`.

### Method
`new`

### Parameters
None

### Returns
A new `NoStdTrainingRecorder` instance.
```

--------------------------------

### Get Last Element of a Slice

Source: https://docs.rs/burn/latest/burn/tensor/struct.Bytes

Use `last` to get an immutable reference to the last element. Returns `None` if the slice is empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

--------------------------------

### SwiGluConfig::new

Source: https://docs.rs/burn/latest/burn/nn/struct.SwiGluConfig

Creates a new instance of the SwiGluConfig.

```APIDOC
## Function new

Create a new instance of the config.

### Signature

```rust
pub fn new(d_input: usize, d_output: usize) -> SwiGluConfig
```

### Parameters

* `d_input`: usize - The size of the input features.
* `d_output`: usize - The size of the output features.
```

--------------------------------

### Example Implementation of SerializeTuple

Source: https://docs.rs/burn/latest/burn/serde/ser/trait.SerializeTuple

This section provides a more detailed example of implementing the SerializeTuple trait, including the definition of associated types and placeholder methods.

```APIDOC
## Example Implementation of SerializeTuple

### Description

This example provides a concrete implementation of the `SerializeTuple` trait, illustrating how to define the associated `Error` and `Ok` types and outlining the structure for serialization methods.

### Implementation Details

```rust
// Define a custom error type for serialization
#[derive(Debug)]
struct MyTupleError(String);

impl std::fmt::Display for MyTupleError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Serialization error: {}", self.0)
    }
}

impl std::error::Error for MyTupleError {}

// Define a type to hold the serialized output
struct MySerializedOutput {
    bytes: Vec<u8>,
}

// Implement the SerializeTuple trait
struct MyDataStructure<'a> {
    items: &'a [&'a str],
}

impl<'a> SerializeTuple for MyDataStructure<'a> {
    type Error = MyTupleError;
    type Ok = MySerializedOutput;

    // Placeholder for a method that would serialize the tuple
    fn serialize_tuple_element(&mut self, _element: &str) -> Result<Self::Ok, Self::Error> {
        // In a real implementation, this would process an element
        // and potentially return a partial result or update internal state.
        // For this example, we'll just return a dummy success.
        Ok(MySerializedOutput { bytes: vec![0] })
    }

    // Placeholder for a method that would finalize the serialization
    fn finalize_tuple(&mut self) -> Result<Self::Ok, Self::Error> {
        // In a real implementation, this would combine all serialized elements
        // into the final output.
        Ok(MySerializedOutput { bytes: vec![1, 2, 3] })
    }
}
```

### Notes

*   The `serialize_tuple_element` and `finalize_tuple` methods are illustrative. Actual implementations would contain the logic for converting data into the desired serialized format.
```

--------------------------------

### Tensor Creation and Manipulation Example

Source: https://docs.rs/burn/latest/burn/prelude/struct.Tensor

Demonstrates creating a tensor, slicing it to extract sub-tensors, and indexing to select specific elements. Requires a Backend implementation.

```rust
use burn_tensor::backend::Backend;
use burn_tensor::Tensor;
use burn_tensor::Int;

fn example<B: Backend>() {
    let device = Default::default();

    let tensor = Tensor::<B, 2>::from_data(
        [
            [3.0, 4.9, 2.0],
            [2.0, 1.9, 3.0],
            [6.0, 1.5, 7.0],
            [3.0, 4.9, 9.0],
        ],
        &device,
    );

    // Slice the tensor to get the second and third rows:
    // [[2.0, 1.9, 3.0], [6.0, 1.5, 7.0]]
    // The resulting tensor will have dimensions [2, 3].
    let slice = tensor.clone().slice([1..3]);
    println!("{slice}");

    // Slice the tensor to get the first two rows and the first 2 columns:
    // [[3.0, 4.9], [2.0, 1.9]]
    // The resulting tensor will have dimensions [2, 2].
    let slice = tensor.clone().slice([0..2, 0..2]);
    println!("{slice}");

    // Index the tensor along the dimension 1 to get the elements 0 and 2:
    // [[3.0, 2.0], [2.0, 3.0], [6.0, 7.0], [3.0, 9.0]]
    // The resulting tensor will have dimensions [4, 2]
    let indices = Tensor::<B, 1, Int>::from_data([0, 2], &device);
    let indexed = tensor.select(1, indices);
    println!("{indexed}");
}
```

--------------------------------

### Example Implementation of SerializeStruct for Rgb

Source: https://docs.rs/burn/latest/burn/serde/ser/trait.SerializeStruct

This example shows how to implement the Serialize trait for a custom struct `Rgb` by using `SerializeStruct` to serialize its fields.

```rust
use serde::ser::{Serialize, SerializeStruct, Serializer};

struct Rgb {
    r: u8,
    g: u8,
    b: u8,
}

impl Serialize for Rgb {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut rgb = serializer.serialize_struct("Rgb", 3)?;
        rgb.serialize_field("r", &self.r)?;
        rgb.serialize_field("g", &self.g)?;
        rgb.serialize_field("b", &self.b)?;
        rgb.end()
    }
}
```

--------------------------------

### InstanceNormConfig Methods

Source: https://docs.rs/burn/latest/burn/nn/struct.InstanceNormConfig

The InstanceNormConfig struct provides the following methods for initialization and configuration: init, new, with_affine, and with_epsilon.

```APIDOC
## InstanceNormConfig Methods

### Methods

*   `init()`: Initializes the InstanceNormConfig.
*   `new()`: Creates a new InstanceNormConfig.
*   `with_affine(affine: bool)`: Sets the affine transformation option.
*   `with_epsilon(epsilon: f64)`: Sets the epsilon value.
```

--------------------------------

### SerializeTuple Trait - Example Use (Tuple)

Source: https://docs.rs/burn/latest/burn/serde/ser/trait.SerializeTuple

This example demonstrates how to implement the Serialize trait for a 3-element tuple, utilizing the SerializeTuple trait to serialize its elements.

```APIDOC
## Example use
```rust
use serde::ser::{Serialize, SerializeTuple, Serializer};

impl<A, B, C>
    Serialize for (A, B, C)
where
    A: Serialize,
    B: Serialize,
    C: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut tup = serializer.serialize_tuple(3)?;
        tup.serialize_element(&self.0)?;
        tup.serialize_element(&self.1)?;
        tup.serialize_element(&self.2)?;
        tup.end()
    }
}
```
```

--------------------------------

### GradientClipping::init

Source: https://docs.rs/burn/latest/burn/grad_clipping/enum.GradientClipping

Initializes a new instance with the given initializer. This is an unsafe operation.

```APIDOC
## unsafe fn init

### Description
Initializes a with the given initializer.

### Parameters
- **init** (<T as Pointable>::Init) - Description of the initializer.

### Returns
- **usize** - The index of the initialized element.
```

--------------------------------

### Example Usage of SerializeTupleVariant

Source: https://docs.rs/burn/latest/burn/serde/ser/trait.SerializeTupleVariant

Demonstrates how to implement the SerializeTupleVariant trait for an enum with tuple variants. This example shows serialization for variants with different numbers of fields.

```rust
use serde::ser::{Serialize, SerializeTupleVariant, Serializer};

enum E {
    T(u8, u8),
    U(String, u32, u32),
}

impl Serialize for E {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match *self {
            E::T(ref a, ref b) => {
                let mut tv = serializer.serialize_tuple_variant("E", 0, "T", 2)?;
                tv.serialize_field(a)?;
                tv.serialize_field(b)?;
                tv.end()
            }
            E::U(ref a, ref b, ref c) => {
                let mut tv = serializer.serialize_tuple_variant("E", 1, "U", 3)?;
                tv.serialize_field(a)?;
                tv.serialize_field(b)?;
                tv.serialize_field(c)?;
                tv.end()
            }
        }
    }
}
```

--------------------------------

### BatchNormConfig::init

Source: https://docs.rs/burn/latest/burn/nn/struct.BatchNormConfig

Initializes a new BatchNorm module with the specified backend and device.

```APIDOC
## BatchNormConfig::init

### Description
Initializes a new batch norm module.

### Signature
```rust
pub fn init<B, const D: usize>(
    &self,
    device: &<B as Backend>::Device,
) -> BatchNorm<B, D>
where
    B: Backend,
```

### Parameters
* `device`: A reference to the device on which the BatchNorm module will be initialized.
```

--------------------------------

### SerializeTuple Trait - Example Use (Array)

Source: https://docs.rs/burn/latest/burn/serde/ser/trait.SerializeTuple

This example shows the implementation of the Serialize trait for a fixed-size array of 16 elements, using SerializeTuple to serialize each element.

```APIDOC
## Example use
```rust
use serde::ser::{Serialize, SerializeTuple, Serializer};

impl<T>
    Serialize for [T; 16]
where
    T: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut seq = serializer.serialize_tuple(16)?;
        for element in self {
            seq.serialize_element(element)?;
        }
        seq.end()
    }
}
```
```

--------------------------------

### SwiGluConfig::init

Source: https://docs.rs/burn/latest/burn/nn/struct.SwiGluConfig

Initializes a new SwiGLU activation layer on a specified device.

```APIDOC
## pub fn init<B>(&self, device: &<B as Backend>::Device) -> SwiGlu<B>

Initialize a new [SwiGLU](https://docs.rs/burn/latest/burn/nn/struct.SwiGlu.html "struct burn::nn::SwiGlu") activation layer.
```

--------------------------------

### init

Source: https://docs.rs/burn/latest/burn/module/struct.DisplaySettings

Initializes a with the given initializer.

```APIDOC
## init

### Description
Initializes a with the given initializer.

### Signature
`unsafe fn init(init: <T as Pointable>::Init) -> usize`
```

--------------------------------

### Get Mutable First Chunk of Slice

Source: https://docs.rs/burn/latest/burn/tensor/struct.Bytes

Use `first_chunk_mut` to get a mutable reference to the first N elements of a slice. Returns `None` if the slice is shorter than N.

```rust
let x = &mut [0, 1, 2];

if let Some(first) = x.first_chunk_mut::<2>() {
    first[0] = 5;
    first[1] = 4;
}
assert_eq!(x, &[5, 4, 2]);

assert_eq!(None, x.first_chunk_mut::<4>());
```

--------------------------------

### Get Last Element Mutably

Source: https://docs.rs/burn/latest/burn/tensor/struct.Bytes

Use `last_mut` to get a mutable reference to the last element. Returns `None` if the slice is empty. Modifies the last element in place.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.last_mut());
```

--------------------------------

### RmsNormConfig Methods

Source: https://docs.rs/burn/latest/burn/nn/struct.RmsNormConfig

RmsNormConfig provides methods for initialization and configuration, including `init`, `new`, and `with_epsilon`.

```APIDOC
## RmsNormConfig Methods

### init
- Description: Initializes the RmsNormConfig.

### new
- Description: Creates a new RmsNormConfig with default values.

### with_epsilon
- Description: Sets the epsilon value for the RmsNormConfig.
```

--------------------------------

### DefaultRecorder::new

Source: https://docs.rs/burn/latest/burn/record/type.DefaultRecorder

Creates a new instance of DefaultRecorder. This is the primary way to initialize the recorder for use.

```APIDOC
## new

Creates a new instance of `DefaultRecorder`.

### Method Signature

```rust
pub fn new() -> DefaultRecorder
```

### Description

This function initializes and returns a new `DefaultRecorder` object, ready to be used for recording or replaying model states.
```

--------------------------------

### Example Use of SerializeTuple

Source: https://docs.rs/burn/latest/burn/serde/ser/trait.SerializeTuple

This section provides an example demonstrating how the SerializeTuple trait can be used in practice. It illustrates the typical implementation pattern and how to leverage the associated `Error` and `Ok` types.

```APIDOC
## Example Use of SerializeTuple

### Description

This example showcases a practical application of the `SerializeTuple` trait. It demonstrates how to implement the trait for a custom data structure and how to utilize its associated types for error management and successful serialization.

### Usage

```rust
// Assuming a struct `MyTuple` that needs to be serialized
struct MyTuple<'a> {
    data: &'a [u8],
}

// Implementation of SerializeTuple for MyTuple
impl<'a> SerializeTuple for MyTuple<'a> {
    type Error = MySerializationError;
    type Ok = SerializedData;

    // ... methods for serialization would be defined here ...
}

// Define custom error and success types
struct MySerializationError;
struct SerializedData;
```

### Key Components

*   **`type Error = MySerializationError;`**: Specifies that `MySerializationError` is the type used for reporting serialization failures.
*   **`type Ok = SerializedData;`**: Indicates that `SerializedData` is the type returned upon successful serialization.
```

--------------------------------

### DeformConv2dConfig::init

Source: https://docs.rs/burn/latest/burn/nn/conv/struct.DeformConv2dConfig

Initializes a new DeformConv2d module with the specified configuration and device.

```APIDOC
## DeformConv2dConfig::init

### Description
Initialize a new [DeformConv2d](https://docs.rs/burn/latest/burn/nn/conv/struct.DeformConv2d.html) module.

### Signature
```rust
pub fn init<B: Backend>(&self, device: &<B as Backend>::Device) -> DeformConv2d<B>
```

### Type Parameters
* `B`: A type that implements the `Backend` trait.

### Parameters
* `device`: A reference to the device on which to initialize the module.
```

--------------------------------

### Get First Chunk of a Slice

Source: https://docs.rs/burn/latest/burn/tensor/struct.Bytes

Use `first_chunk` with a const generic `N` to get an array reference to the first `N` items. Returns `None` if the slice is shorter than `N`.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

--------------------------------

### Example Implementation of Error Trait

Source: https://docs.rs/burn/latest/burn/serde/ser/trait.Error

An example demonstrating how to implement the `Error` trait for a custom type (e.g., `Path`) to handle serialization errors, specifically when encountering invalid UTF-8 characters.

```APIDOC
## Example Implementation

```rust
use serde::ser::{self, Serialize, Serializer};

impl Serialize for Path {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match self.to_str() {
            Some(s) => serializer.serialize_str(s),
            None => Err(ser::Error::custom("path contains invalid UTF-8 characters")),
        }
    }
}
```
```

--------------------------------

### Init

Source: https://docs.rs/burn/latest/burn/lr_scheduler/noam/struct.NoamLrScheduler

The type for initializers.

```APIDOC
## type Init = T

### Description
The type for initializers.
```

--------------------------------

### Deserialize Timestamp Example

Source: https://docs.rs/burn/latest/burn/serde/de/trait.Deserializer

Implement `Deserialize` for a custom `Timestamp` type. This example shows how to conditionally deserialize from a human-readable string or a compact binary representation based on whether the deserializer is human-readable.

```rust
use serde::de::{self, Deserialize, Deserializer};

impl<'de> Deserialize<'de> for Timestamp {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        if deserializer.is_human_readable() {
            // Deserialize from a human-readable string like "2015-05-15T17:01:00Z".
            let s = String::deserialize(deserializer)?;
            Timestamp::from_str(&s).map_err(de::Error::custom)
        } else {
            // Deserialize from a compact binary representation, seconds since
            // the Unix epoch.
            let n = u64::deserialize(deserializer)?;
            Ok(Timestamp::EPOCH + Duration::seconds(n))
        }
    }
}
```

--------------------------------

### HardSigmoidConfig Initialization and Configuration

Source: https://docs.rs/burn/latest/burn/nn/struct.HardSigmoidConfig

Demonstrates how to create and configure a HardSigmoidConfig struct using its associated methods.

```APIDOC
## HardSigmoidConfig

Configuration to create a [Hard Sigmoid](https://docs.rs/burn/latest/burn/nn/struct.HardSigmoid.html "struct burn::nn::HardSigmoid") layer using the [init function](https://docs.rs/burn/latest/burn/nn/struct.HardSigmoidConfig.html#method.init "method burn::nn::HardSigmoidConfig::init").

### Fields

* `alpha`: f64 - The alpha value. Default is 0.2
* `beta`: f64 - The beta value. Default is 0.5

### Methods

#### `new()`

```rust
pub fn new() -> HardSigmoidConfig
```

Create a new instance of the config.

#### `with_alpha(alpha: f64)`

```rust
pub fn with_alpha(self, alpha: f64) -> HardSigmoidConfig
```

Sets the alpha value for the configuration.

#### `with_beta(beta: f64)`

```rust
pub fn with_beta(self, beta: f64) -> HardSigmoidConfig
```

Sets the beta value for the configuration.

#### `init()`

```rust
pub fn init(&self) -> HardSigmoid
```

Initialize a new [Hard Sigmoid](https://docs.rs/burn/latest/burn/nn/struct.HardSigmoid.html "struct burn::nn::HardSigmoid") Layer
```

--------------------------------

### Get Slice as Array (Nightly)

Source: https://docs.rs/burn/latest/burn/tensor/struct.Bytes

This nightly-only experimental API attempts to get a reference to the underlying array. It returns None if the specified size N does not exactly match the slice length.

```rust
let data = [1, 2, 3];
let slice = &data[..];

let arr_ref: Option<&[[i32; 3]]> = slice.as_array();
assert!(arr_ref.is_some());

let arr_ref_wrong_size: Option<&[[i32; 2]]> = slice.as_array();
assert!(arr_ref_wrong_size.is_none());
```

--------------------------------

### DebugRecordSettings::new

Source: https://docs.rs/burn/latest/burn/record/type.DebugRecordSettings

Creates a new instance of DebugRecordSettings.

```APIDOC
## new

Creates a new instance of `DebugRecordSettings`.

### Method

```rust
pub fn new() -> DebugRecordSettings
```

### Returns

A new `DebugRecordSettings` instance.
```

--------------------------------

### PReluConfig Methods

Source: https://docs.rs/burn/latest/burn/nn/struct.PReluConfig

Available methods for PReluConfig include init, new, with_alpha, and with_num_parameters.

```APIDOC
## PReluConfig Methods

### init

- Description: Initializes the PReluConfig.
- Signature: `fn init() -> Self`

### new

- Description: Creates a new PReluConfig.
- Signature: `fn new() -> Self`

### with_alpha

- Description: Sets the alpha parameter for PReluConfig.
- Signature: `fn with_alpha(alpha: Alpha) -> Self`

### with_num_parameters

- Description: Sets the number of parameters for PReluConfig.
- Signature: `fn with_num_parameters(num_parameters: usize) -> Self`
```

--------------------------------

### Module Definition Example

Source: https://docs.rs/burn/latest/burn/module/trait.Module

An example demonstrating how to define a custom module `MyModule` using the `#[derive(Module)]` attribute. The module is generic over a backend `B` and includes a linear layer and a usize field.

```APIDOC
## Example
A module should have a [backend](https://docs.rs/burn/latest/burn/prelude/trait.Backend.html "trait burn::prelude::Backend") defined as a generic parameter B. This will be used by the [derive](https://docs.rs/burn/latest/burn/module/derive.Module.html "derive burn::module::Module") attribute to generate the code necessary to optimize and train the module on any backend.
```rust
// Not necessary when using the burn crate directly.
use burn_core as burn;

use burn::{
    nn,
    module::Module,
    tensor::Tensor,
    tensor::backend::Backend,
};

#[derive(Module, Debug)]
struct MyModule<B: Backend> {
  my_param: nn::Linear<B>,
  my_other_field: usize,
}
```
```

--------------------------------

### BinaryCrossEntropyLossConfig::init

Source: https://docs.rs/burn/latest/burn/nn/loss/struct.BinaryCrossEntropyLossConfig

Initializes the Binary Cross-entropy loss with the given configuration and device.

```APIDOC
## BinaryCrossEntropyLossConfig::init

### Description
Initialize [Binary Cross-entropy loss](https://docs.rs/burn/latest/burn/nn/loss/struct.BinaryCrossEntropyLoss.html "struct burn::nn::loss::BinaryCrossEntropyLoss").

### Parameters
- **device** (&B::Device) - Required - The device on which to initialize the loss.

### Type Parameters
- **B**: Must implement the [Backend](https://docs.rs/burn/latest/burn/prelude/trait.Backend.html "trait burn::prelude::Backend") trait.

### Returns
- [BinaryCrossEntropyLoss<B>]: An initialized BinaryCrossEntropyLoss instance.
```

--------------------------------

### Get Mutable Slice as Array (Nightly)

Source: https://docs.rs/burn/latest/burn/tensor/struct.Bytes

This nightly-only experimental API attempts to get a mutable reference to the underlying array. It returns None if the specified size N does not exactly match the slice length.

```rust
let mut data = [1, 2, 3];
let slice = &mut data[..];

let arr_mut_ref: Option<&mut [[i32; 3]]> = slice.as_mut_array();
assert!(arr_mut_ref.is_some());

if let Some(arr) = arr_mut_ref {
    arr[0][0] = 10;
}
assert_eq!(data, [10, 2, 3]);

let arr_mut_ref_wrong_size: Option<&mut [[i32; 2]]> = slice.as_mut_array();
assert!(arr_mut_ref_wrong_size.is_none());
```

--------------------------------

### init Method

Source: https://docs.rs/burn/latest/burn/nn/attention/struct.MultiHeadAttentionConfig

Initializes a with the given initializer. This is an unsafe function.

```APIDOC
## init

### Description
Initializes a with the given initializer.

### Signature
`unsafe fn init(init: <T as Pointable>::Init) -> usize`

### Safety
This function is unsafe and requires the caller to ensure the initializer is valid.
```

--------------------------------

### type_id

Source: https://docs.rs/burn/latest/burn/optim/struct.RmsPropMomentumStateItem

Gets the TypeId of the RmsPropMomentumStateItem.

```APIDOC
## fn type_id

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
None

### Response
- **TypeId**: The type identifier of the object.
```

--------------------------------

### Pointable init

Source: https://docs.rs/burn/latest/burn/module/struct.ParamId

Initializes a with the given initializer.

```APIDOC
## unsafe fn init(init: <T as Pointable>::Init) -> usize

### Description
Initializes a with the given initializer.
```

--------------------------------

### type_id

Source: https://docs.rs/burn/latest/burn/nn/loss/struct.BinaryCrossEntropyLoss

Gets the TypeId of the BinaryCrossEntropyLoss.

```APIDOC
## type_id

### Description
Gets the `TypeId` of `self`.

### Method
`type_id()`

### Parameters
None

### Response
- **TypeId**: The `TypeId` of the object.
```

--------------------------------

### Stateful Deserialization API Example

Source: https://docs.rs/burn/latest/burn/serde/de/trait.DeserializeSeed

Shows how to adjust an API to support stateful deserialization by accepting a DeserializeSeed.

```rust
fn func_seed<'de, T: DeserializeSeed<'de>>(seed: T) -> Result<T::Value, Error>
```

--------------------------------

### Example Usage of SerializeTupleStruct

Source: https://docs.rs/burn/latest/burn/serde/ser/trait.SerializeTupleStruct

This example demonstrates how to implement the `Serialize` trait for a custom struct `Rgb` by utilizing the `SerializeTupleStruct` trait. It shows the typical pattern of creating a tuple struct serializer, serializing each field, and then ending the serialization.

```APIDOC
## Example Use

```rust
use serde::ser::{Serialize, SerializeTupleStruct, Serializer};

struct Rgb(u8, u8, u8);

impl Serialize for Rgb {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
        ts.serialize_field(&self.0)?;
        ts.serialize_field(&self.1)?;
        ts.serialize_field(&self.2)?;
        ts.end()
    }
}
```
```

--------------------------------

### type_id

Source: https://docs.rs/burn/latest/burn/tensor/ops/struct.Conv2dBackward

Gets the TypeId of the Conv2dBackward instance.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
fn type_id(&self) -> TypeId
```

--------------------------------

### type_id

Source: https://docs.rs/burn/latest/burn/prelude/struct.TensorData

Gets the TypeId of the TensorData instance.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
None

### Response
- **TypeId**: The `TypeId` of the instance.
```

--------------------------------

### QuantScheme Method: init

Source: https://docs.rs/burn/latest/burn/tensor/quantization/struct.QuantScheme

Initializes a with the given initializer. This is an unsafe function.

```APIDOC
#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. [Read more](https://docs.rs/crossbeam-epoch/0.9.18/x86_64-unknown-linux-gnu/crossbeam_epoch/atomic/trait.Pointable.html#tymethod.init)
```

--------------------------------

### type_id

Source: https://docs.rs/burn/latest/burn/optim/struct.AdamWConfig

Gets the TypeId of the AdamWConfig instance.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
fn
```

--------------------------------

### Relu::type_id

Source: https://docs.rs/burn/latest/burn/nn/struct.Relu

Gets the `TypeId` of `self`.

```APIDOC
## fn type_id

### Description
Gets the `TypeId` of `self`.

### Signature
```rust
fn type_id(&self) -> TypeId
```

### Returns
A `TypeId` representing the type of the object.
```

--------------------------------

### From

Source: https://docs.rs/burn/latest/burn/nn/struct.SwiGluConfig

Creates a `SwiGluConfig` instance from another value of the same type.

```APIDOC
## fn from

### Description
Returns the argument unchanged.

### Method
`from`

### Parameters
- **t** (`T`): The value to convert.

### Returns
- `T`: The original value.
```

--------------------------------

### num_params

Source: https://docs.rs/burn/latest/burn/nn/struct.Gelu

Gets the number of parameters of the module.

```APIDOC
## fn num_params

### Description
Gets the number of the parameters of the module.

### Signature
```rust
fn num_params(&self) -> usize
```

### Returns
* `usize` - The number of parameters.
```

--------------------------------

### ConvTranspose2dConfig::init

Source: https://docs.rs/burn/latest/burn/nn/conv/struct.ConvTranspose2dConfig

Initializes a new ConvTranspose2d module with the specified configuration and device.

```APIDOC
## pub fn init<B: Backend>(&self, device: &<B as Backend>::Device) -> ConvTranspose2d<B>

Initialize a new conv transpose 2d module.
```

--------------------------------

### GradientClippingConfig::init()

Source: https://docs.rs/burn/latest/burn/grad_clipping/enum.GradientClippingConfig

Initializes the gradient clipping configuration. This method is part of the GradientClippingConfig implementation.

```APIDOC
## Method: init

### Description

Initialize the gradient clipping.

### Signature

```rust
pub fn init(&self) -> GradientClipping
```

### Returns

The gradient clipping configuration.
```

--------------------------------

### type_id

Source: https://docs.rs/burn/latest/burn/nn/struct.GroupNormConfig

Gets the TypeId of the GroupNormConfig instance.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
None

### Response
- **TypeId**: The unique identifier for the type of `self`.
```

--------------------------------

### PositionalEncodingConfig::init

Source: https://docs.rs/burn/latest/burn/nn/struct.PositionalEncodingConfig

Initializes a new PositionalEncoding module with the specified device.

```APIDOC
## PositionalEncodingConfig::init<B>

### Description
Initialize a new [PositionalEncoding](https://docs.rs/burn/latest/burn/nn/struct.PositionalEncoding.html) module.

### Signature
```rust
pub fn init<B>(&self, device: &<B as Backend>::Device) -> PositionalEncoding<B>
where
    B: Backend,
```

### Parameters
* `device`: The device on which to initialize the PositionalEncoding module.
```

--------------------------------

### type_id

Source: https://docs.rs/burn/latest/burn/nn/conv/struct.DeformConv2dConfig

Gets the TypeId of the DeformConv2dConfig instance.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
None

### Response
- **TypeId**: The unique type identifier of the instance.
```

--------------------------------

### ConvTranspose1dConfig::init

Source: https://docs.rs/burn/latest/burn/nn/conv/struct.ConvTranspose1dConfig

Initializes a new ConvTranspose1d module with the specified configuration and device.

```APIDOC
## pub fn init<B>(&self, device: &<B as Backend>::Device) -> ConvTranspose1d<B>

### Description
Initialize a new conv transpose 1d module.

### Parameters
#### Path Parameters
- **device** (<B as Backend>::Device) - The device on which to initialize the module.
```

--------------------------------

### TransformerEncoderLayer::num_params

Source: https://docs.rs/burn/latest/burn/nn/transformer/struct.TransformerEncoderLayer

Gets the number of parameters of the module.

```APIDOC
## fn num_params(&self) -> usize

### Description
Gets the number of the parameters of the module.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```json
{
  "example": "request body not available"
}
```

### Response
#### Success Response (200)
- **usize** - The number of parameters in the module.

#### Response Example
```json
{
  "example": "response body not available"
}
```
```

--------------------------------

### TransformerDecoderLayer::num_params

Source: https://docs.rs/burn/latest/burn/nn/transformer/struct.TransformerDecoderLayer

Gets the number of parameters of the module.

```APIDOC
## fn num_params

### Description
Gets the number of the parameters of the module.

### Parameters
#### Path Parameters
- **self** (Self) - Description not available

### Returns
- **usize** - Description not available
```

--------------------------------

### Relu::num_params

Source: https://docs.rs/burn/latest/burn/nn/struct.Relu

Gets the number of parameters of the module.

```APIDOC
## fn num_params

### Description
Gets the number of the parameters of the module.

### Signature
```rust
fn num_params(&self) -> usize
```

### Returns
A `usize` representing the total number of parameters in the module.
```

--------------------------------

### PReluConfig::init

Source: https://docs.rs/burn/latest/burn/nn/struct.PReluConfig

Initializes a new Parametric ReLU Layer using the provided configuration and device.

```APIDOC
## Method init

Initialize a new [Parametric Relu](struct.PRelu.html) Layer

### Type Parameters

* `B`: A type that implements the `Backend` trait.

### Arguments

* `device`: A reference to the device on which to initialize the layer.

### Returns

* `PRelu<B>` - An initialized Parametric ReLU layer.
```

--------------------------------

### SgdConfig::new

Source: https://docs.rs/burn/latest/burn/optim/struct.SgdConfig

Creates a new instance of the SgdConfig.

```APIDOC
## SgdConfig::new

### Description
Creates a new instance of the config.

### Method
`pub fn new() -> SgdConfig`

### Returns
A new instance of `SgdConfig`.
```

--------------------------------

### InstanceNorm::num_params

Source: https://docs.rs/burn/latest/burn/nn/struct.InstanceNorm

Gets the number of parameters of the module.

```APIDOC
## fn num_params(&self) -> usize

### Description
Gets the number of the parameters of the module.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```json
{
  "example": "request body"
}
```

### Response
#### Success Response (200)
- **num_params** (usize) - The number of parameters in the module.

#### Response Example
```json
{
  "example": "response body"
}
```
```

--------------------------------

### Dropout::num_params

Source: https://docs.rs/burn/latest/burn/nn/struct.Dropout

Gets the number of parameters of the module.

```APIDOC
## fn num_params

### Description
Gets the number of the parameters of the module.

### Signature
`fn num_params(&self) -> usize`

### Returns
* `usize` - The number of parameters.
```
Tokens:
Raw