Struct burn::module::Param

pub struct Param<T>
where
    T: Parameter,
{ /* private fields */ }

Parameters are the fundamental building blocks of modules where they serve as containers for tensors that can be updated during training, and loaded during inference. If you don’t want to save the tensors with a record and/or don’t want to update it during training, you don’t need this type to wrap your tensor.

Laziness

The initialization of parameters can be lazy when created using uninitialized, which can be done using an initializer.

This reduces the amount of allocations done when loading a model for inference without having to create a custom initialization function only for inference.

Example

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);

Implementations

impl<T> Param<T>

where T: Parameter,

pub fn initialized(id: ParamId, value: T) -> Param<T>

Create a new parameter that is already initialized.

pub fn uninitialized<F>( id: ParamId, init: F, device: <T as Parameter>::Device, is_require_grad: bool ) -> Param<T>

where F: Fn(&<T as Parameter>::Device, bool) -> T + Send + 'static,

Create a new parameter that is not already initialized.

pub fn val(&self) -> T

Gets the parameter value.

pub fn into_value(self) -> T

Gets the parameter’s value while consuming the parameter.

pub fn consume(self) -> (ParamId, T)

Gets the parameter id and value while consuming the parameter.

pub fn map<F>(self, func: F) -> Param<T>

where F: Fn(T) -> T,

Execute the given function on the inner value.

pub fn set_require_grad(self, require_grad: bool) -> Param<T>

Override the gradient requirement for the current parameter.

impl<B, const D: usize> Param<Tensor<B, D>>

where B: Backend,

pub fn from_tensor(value: Tensor<B, D>) -> Param<Tensor<B, D>>

Create a new parameter from a float tensor.

Warnings

We strongly recommend using Param::uninitialized if you are using this method to initialize parameters inside a module, since the tensor initialization will be lazy, making the loading of weights more performant.

pub fn from_data<T>( data: T, device: &<B as Backend>::Device ) -> Param<Tensor<B, D>>

where T: Into<Data<<B as Backend>::FloatElem, D>>,

Create a new parameter from data.

Trait Implementations

impl<const D: usize, B> AutodiffModule<B> for Param<Tensor<B, D>>

where B: AutodiffBackend,

type InnerModule = Param<Tensor<<B as AutodiffBackend>::InnerBackend, D>>

Inner module without auto-differentiation.

fn valid(&self) -> <Param<Tensor<B, D>> as AutodiffModule<B>>::InnerModule

Get the same module, but on the inner backend without auto-differentiation.

impl<const D: usize, B> AutodiffModule<B> for Param<Tensor<B, D, Bool>>

where B: AutodiffBackend,

type InnerModule = Param<Tensor<<B as AutodiffBackend>::InnerBackend, D, Bool>>

Inner module without auto-differentiation.

fn valid(&self) -> <Param<Tensor<B, D, Bool>> as AutodiffModule<B>>::InnerModule

Get the same module, but on the inner backend without auto-differentiation.

impl<const D: usize, B> AutodiffModule<B> for Param<Tensor<B, D, Int>>

where B: AutodiffBackend,

type InnerModule = Param<Tensor<<B as AutodiffBackend>::InnerBackend, D, Int>>

Inner module without auto-differentiation.

fn valid(&self) -> <Param<Tensor<B, D, Int>> as AutodiffModule<B>>::InnerModule

Get the same module, but on the inner backend without auto-differentiation.

impl<T> Clone for Param<T>

where T: Parameter,

fn clone(&self) -> Param<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Param<T>

where T: Parameter,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Deref for Param<T>

where T: Parameter,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<Param<T> as Deref>::Target

Dereferences the value.

impl<T> Display for Param<T>

where T: Parameter,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<const D: usize, B> Module<B> for Param<Tensor<B, D>>

where B: Backend,

type Record = Param<Tensor<B, D>>

Type to save and load the module.

fn visit<V>(&self, visitor: &mut V)

where V: ModuleVisitor<B>,

Visit each tensor parameter in the module with a visitor.

fn map<M>(self, mapper: &mut M) -> Param<Tensor<B, D>>

where M: ModuleMapper<B>,

Map each tensor parameter in the module with a mapper.

fn into_record(self) -> <Param<Tensor<B, D>> as Module<B>>::Record

Convert the module into a record containing the state.

fn load_record( self, record: <Param<Tensor<B, D>> as Module<B>>::Record ) -> Param<Tensor<B, D>>

Load the module state from a record.

fn to_device(self, device: &<B as Backend>::Device) -> Param<Tensor<B, D>>

Move the module and all of its sub-modules to the given device.

fn fork(self, device: &<B as Backend>::Device) -> Param<Tensor<B, D>>

Fork the module and all of its sub-modules to the given device.

fn collect_devices( &self, devices: Vec<<B as Backend>::Device> ) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree added to the given vector without duplicates.

fn devices(&self) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree without duplicates.

fn no_grad(self) -> Self

Each tensor in the module tree will not require grad.

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules.

fn save_file<FR, PB>( self, file_path: PB, recorder: &FR ) -> Result<(), RecorderError>

where FR: FileRecorder<B>, PB: Into<PathBuf>,

Save the module to a file using the provided file recorder.

fn load_file<FR, PB>( self, file_path: PB, recorder: &FR, device: &<B as Backend>::Device ) -> Result<Self, RecorderError>

where FR: FileRecorder<B>, PB: Into<PathBuf>,

Load the module from a file using the provided file recorder.

impl<const D: usize, B> Module<B> for Param<Tensor<B, D, Bool>>

where B: Backend,

type Record = Param<Tensor<B, D, Bool>>

Type to save and load the module.

fn visit<V>(&self, visitor: &mut V)

where V: ModuleVisitor<B>,

Visit each tensor parameter in the module with a visitor.

fn map<M>(self, mapper: &mut M) -> Param<Tensor<B, D, Bool>>

where M: ModuleMapper<B>,

Map each tensor parameter in the module with a mapper.

fn into_record(self) -> <Param<Tensor<B, D, Bool>> as Module<B>>::Record

Convert the module into a record containing the state.

fn load_record( self, record: <Param<Tensor<B, D, Bool>> as Module<B>>::Record ) -> Param<Tensor<B, D, Bool>>

Load the module state from a record.

fn to_device(self, device: &<B as Backend>::Device) -> Param<Tensor<B, D, Bool>>

Move the module and all of its sub-modules to the given device.

fn fork(self, device: &<B as Backend>::Device) -> Param<Tensor<B, D, Bool>>

Fork the module and all of its sub-modules to the given device.

fn collect_devices( &self, devices: Vec<<B as Backend>::Device> ) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree added to the given vector without duplicates.

fn devices(&self) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree without duplicates.

fn no_grad(self) -> Self

Each tensor in the module tree will not require grad.

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules.

fn save_file<FR, PB>( self, file_path: PB, recorder: &FR ) -> Result<(), RecorderError>

where FR: FileRecorder<B>, PB: Into<PathBuf>,

Save the module to a file using the provided file recorder.

fn load_file<FR, PB>( self, file_path: PB, recorder: &FR, device: &<B as Backend>::Device ) -> Result<Self, RecorderError>

where FR: FileRecorder<B>, PB: Into<PathBuf>,

Load the module from a file using the provided file recorder.

impl<const D: usize, B> Module<B> for Param<Tensor<B, D, Int>>

where B: Backend,

type Record = Param<Tensor<B, D, Int>>

Type to save and load the module.

fn visit<V>(&self, visitor: &mut V)

where V: ModuleVisitor<B>,

Visit each tensor parameter in the module with a visitor.

fn map<M>(self, mapper: &mut M) -> Param<Tensor<B, D, Int>>

where M: ModuleMapper<B>,

Map each tensor parameter in the module with a mapper.

fn into_record(self) -> <Param<Tensor<B, D, Int>> as Module<B>>::Record

Convert the module into a record containing the state.

fn load_record( self, record: <Param<Tensor<B, D, Int>> as Module<B>>::Record ) -> Param<Tensor<B, D, Int>>

Load the module state from a record.

fn to_device(self, device: &<B as Backend>::Device) -> Param<Tensor<B, D, Int>>

Move the module and all of its sub-modules to the given device.

fn fork(self, device: &<B as Backend>::Device) -> Param<Tensor<B, D, Int>>

Fork the module and all of its sub-modules to the given device.

fn collect_devices( &self, devices: Vec<<B as Backend>::Device> ) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree added to the given vector without duplicates.

fn devices(&self) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree without duplicates.

fn no_grad(self) -> Self

Each tensor in the module tree will not require grad.

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules.

fn save_file<FR, PB>( self, file_path: PB, recorder: &FR ) -> Result<(), RecorderError>

where FR: FileRecorder<B>, PB: Into<PathBuf>,

Save the module to a file using the provided file recorder.

fn load_file<FR, PB>( self, file_path: PB, recorder: &FR, device: &<B as Backend>::Device ) -> Result<Self, RecorderError>

where FR: FileRecorder<B>, PB: Into<PathBuf>,

Load the module from a file using the provided file recorder.

impl<B, const D: usize> Record<B> for Param<Tensor<B, D>>

where B: Backend,

type Item<S: PrecisionSettings> = ParamSerde<FloatTensorSerde<S>>

Type of the item that can be serialized and deserialized.

fn into_item<S>(self) -> <Param<Tensor<B, D>> as Record<B>>::Item<S>

where S: PrecisionSettings,

Convert the current record into the corresponding item that follows the given settings.

fn from_item<S>( item: <Param<Tensor<B, D>> as Record<B>>::Item<S>, device: &<B as Backend>::Device ) -> Param<Tensor<B, D>>

where S: PrecisionSettings,

Convert the given item into a record.

impl<B, const D: usize> Record<B> for Param<Tensor<B, D, Bool>>

where B: Backend,

type Item<S: PrecisionSettings> = ParamSerde<BoolTensorSerde>

Type of the item that can be serialized and deserialized.

fn into_item<S>(self) -> <Param<Tensor<B, D, Bool>> as Record<B>>::Item<S>

where S: PrecisionSettings,

Convert the current record into the corresponding item that follows the given settings.

fn from_item<S>( item: <Param<Tensor<B, D, Bool>> as Record<B>>::Item<S>, device: &<B as Backend>::Device ) -> Param<Tensor<B, D, Bool>>

where S: PrecisionSettings,

Convert the given item into a record.

impl<B, const D: usize> Record<B> for Param<Tensor<B, D, Int>>

where B: Backend,

type Item<S: PrecisionSettings> = ParamSerde<IntTensorSerde<S>>

Type of the item that can be serialized and deserialized.

fn into_item<S>(self) -> <Param<Tensor<B, D, Int>> as Record<B>>::Item<S>

where S: PrecisionSettings,

Convert the current record into the corresponding item that follows the given settings.

fn from_item<S>( item: <Param<Tensor<B, D, Int>> as Record<B>>::Item<S>, device: &<B as Backend>::Device ) -> Param<Tensor<B, D, Int>>

where S: PrecisionSettings,

Convert the given item into a record.