Struct Param 

pub struct Param<T>
where
    T: ParameterValue,
{
    pub id: ParamId,
    /* private fields */
}

Parameters are identified, traversable values owned by modules.

Most parameters contain tensors that can be updated during training and loaded during inference. Parameters can also contain module control state such as Flag, allowing it to participate in module traversal and parameter group selection without pretending to be a tensor.

Cloning

Cloning a parameter is always cheap; it never allocates or initializes tensors. Clones share the same lazy initialization state, so initialization happens at most once and all clones resolve to the same value regardless of which one triggered it.

This sharing is strictly scoped to lazy initialization. It only guarantees that all clones observe the same initialization result. Subsequent transformations operate on independent parameter values and never propagate across clones.

Fields

id: ParamId

The unique ID of this parameter. This is used by eg. optimizers to associate a gradient with a specific parameter.

Implementations

impl<T> Param<T>

where T: ParameterValue,

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

Create a new parameter that is already initialized.

pub fn val(&self) -> T

Gets the effective parameter value, initializing it lazily if needed.

For initialized parameters, this returns a clone of the cached value. For uninitialized parameters, this triggers initialization.

When a reparameterization is attached, this materializes its effective value. Use base to access the raw stored value without materialization. Conceptually, materialization composes the structural base with the attached reparameterization state.

pub fn base(&self) -> T

Gets the raw stored parameter value without applying its reparameterization.

pub fn is_initialized(&self) -> bool

Check if the parameter has been initialized.

Returns true if the parameter’s value has been computed and cached, false if it’s still lazy and will be initialized on first access.

pub fn into_value(self) -> T

Gets the parameter’s value while consuming the parameter.

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

Gets the parameter id and raw value while consuming the parameter.

Any attached reparameterization is dropped. During module traversal, Param<Tensor<D>>::map detaches the reparameterization before calling ModuleMapper::map_float, traverses it separately, and reattaches it afterward.

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

where F: FnOnce(T) -> T,

Execute the given function on the inner value while preserving its configured training state.

Transforming the effective value must not implicitly change what Module::train restores. Use the explicit activation APIs, such as Param::set_require_grad for tensor parameters, to change that state.

pub fn from_mapped_value( id: ParamId, value: T, param_mapper: ParamMapper<T>, ) -> Param<T>

Create an initialized parameter with the given id, value, and param mapper.

This is a helper method for creating parameters while preserving the param mapper, typically used in ModuleMapper implementations.

impl<T> Param<T>

where T: Parameter,

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

where F: FnOnce(&Device, bool) -> T + Send + Sync + 'static,

Create a new parameter that is not already initialized.

The initializer receives the device and effective gradient requirement, which is false on devices without autodiff. The requested is_require_grad setting is preserved for Module::train. The initializer must create the value on the device it receives, which is not device when the parameter moves before initializing.

pub fn reparameterization<R>(&self) -> Option<&R>

where R: Reparameterization,

The concrete reparameterization attached to this parameter, if any.

pub fn adapter(&self) -> Option<&LoraAdapter>

The LoRA adapter attached to this parameter, if any.

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

where F: Fn(T) -> T + Send + Sync + 'static,

Runs a transformation on the parameter when loading.

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

where F: Fn(T) -> T + Send + Sync + 'static,

Runs a transformation on the parameter when saving.

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

where F: Fn(T) -> T + Send + Sync + 'static, T: Sync + 'static,

Returns a new parameter whose initialization value is transformed by the given function.

If the parameter is still uninitialized (lazy), the transformation is chained onto the existing initialization without triggering evaluation. If the parameter is already initialized, it immediately applies the transformation to the current value.

pub fn lazy_device(&self) -> Device

The device on which the parameter is or will be initialized, without triggering initialization.

This is critical for the load optimization: when loading tensors into an uninitialized parameter, we need to know the target device to move the loaded tensor appropriately, but we don’t want to trigger the initialization function (which would allocate an unnecessary tensor).

Use this instead of crate::tensor::Tensor::device when you need the device but want to preserve lazy initialization.

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

Override the gradient-tracking setting for the current parameter.

On a backend without autodiff the effective tensor remains detached, but the setting is preserved and takes effect through Module::train.

pub fn lazy_shape(&self) -> Shape

The shape of the parameter, without triggering initialization.

This is critical for shape validation during loading: when applying tensors to an uninitialized parameter, we need to validate the shape without triggering the initialization function (which would allocate an unnecessary tensor).

Use this instead of crate::tensor::Tensor::shape when you need the shape but want to preserve lazy initialization.

pub fn transform_for_load(self, tensor: T, param_id: ParamId) -> Param<T>

Transform a parameter for loading by applying load transformations.

This method is used to restore a parameter from a tensor (typically during deserialization). It ensures the tensor is moved to the expected device, applies the param mapper’s on_load transformation, and preserves the autodiff settings (require_grad).

pub fn transform_for_save(&self) -> Param<T>

Transform a parameter for saving by applying save transformations.

This method is used to prepare a parameter for saving (typically during serialization). It applies the param mapper’s on_save transformation, which can be used to modify the tensor before serialization (e.g., quantization, precision conversion).

impl Param<Flag>

pub fn from_bool(value: bool) -> Param<Flag>

Create an identified flag with a fresh parameter id.

pub fn with_value(self, value: bool) -> Param<Flag>

Return this parameter with its flag set to the given value.

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

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

Create a new trainable 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: &Device) -> Param<Tensor<D>>

where T: Into<TensorData>,

Create a new parameter from data.

Trait Implementations

impl<T> Clone for Param<T>

where T: ParameterValue,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Param<T>

where T: ParameterValue,

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

Formats the value using the given formatter.

impl<T> Deref for Param<T>

where T: ParameterValue,

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: ParameterValue,

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

Formats the value using the given formatter.

impl Module for Param<Flag>

fn map<M>(self, mapper: &mut M) -> Param<Flag>

where M: ModuleMapper,

Map each parameter and module-owned control value with a mapper.

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

where V: ModuleVisitor,

Visit each parameter and module-owned control value with a visitor.

fn to_device(self, _device: &Device) -> Param<Flag>

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

fn fork(self, _device: &Device) -> Param<Flag>

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

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

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

fn materialize(self) -> Param<Flag>

Fold parameter reparameterizations into their effective values and remove them.

fn valid(&self) -> Param<Flag>

Returns a validation snapshot without autodiff or active training flags.

fn train(self) -> Param<Flag>

Enables autodiff and restores configured training state throughout the module.

fn devices(&self) -> Vec<Device>

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

fn set_require_grad(self, require_grad: bool) -> Self

Set whether every floating-point tensor parameter in the module tree requires gradients.

fn set_require_grad_group(self, group: ParamGroup, require_grad: bool) -> Self

Set whether matched floating-point tensor parameters require gradients.

fn no_grad(self) -> Self

Disable gradients for every floating-point tensor parameter in the module tree.

fn freeze(self) -> Self

Freeze the whole module tree.

fn unfreeze(self) -> Self

Unfreeze the whole module tree.

fn freeze_group(self, group: ParamGroup) -> Self

Freeze every module-owned value in the given group, leaving the rest of the module untouched.

fn unfreeze_group(self, group: ParamGroup) -> Self

Unfreeze every module-owned value in the given group, leaving the rest of the module untouched.

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules, without initializing the ones not initialized yet.

fn quantize_weights(self, quantizer: &mut Quantizer) -> Self

Quantize the weights of the module.

fn quantize_weights_group( self, quantizer: &mut Quantizer, group: ParamGroup, ) -> Self

Quantize the weights of the given parameter group.

fn apply_reparameterization<R>(self, reparameterizer: R) -> Self

where Self: Sized, R: Reparameterizer,

Attach reparameterizations using the given Reparameterizer.

fn apply_lora(self, lora: Lora) -> Self

where Self: Sized,

Attach LoRA adapters to the module’s 2-D weights, freezing all base tensor parameters.

fn apply_qlora(self, qlora: QLora) -> Self

where Self: Sized,

Apply QLoRA to the module: quantize the (frozen) base tensor parameters and attach trainable LoRA adapters to 2-D weights.

fn into_record(self) -> ModuleRecord

where Self: Sized,

Collect this module’s tensor parameters into a ModuleRecord.

fn into_record_group(self, group: ParamGroup) -> ModuleRecord

where Self: Sized,

Collect the tensor parameters group names into a ModuleRecord.

fn try_load_record(self, record: ModuleRecord) -> Result<Self, RecordError>

where Self: Sized,

Apply a ModuleRecord to this module, returning the loaded module.

fn load_record(self, record: ModuleRecord) -> Self

where Self: Sized,

Apply a ModuleRecord to this module, consuming and returning it.

fn save_file<P>(self, path: P) -> Result<(), RecordError>

where P: AsRef<Path>, Self: Sized,

Save this module’s parameters to a burnpack file on disk.

fn load_file<P>(self, path: P) -> Self

where P: AsRef<Path>, Self: Sized,

Load this module’s parameters from a burnpack file on disk, returning the loaded module.

fn try_load_file<P>(self, path: P) -> Result<Self, RecordError>

where P: AsRef<Path>, Self: Sized,

Fallible variant of load_file.

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

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

where V: ModuleVisitor,

Visit each parameter and module-owned control value with a visitor.

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

where M: ModuleMapper,

Map each parameter and module-owned control value with a mapper.

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

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

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

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

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

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

fn valid(&self) -> Param<Tensor<D>>

Returns a validation snapshot without autodiff or active training flags.

fn materialize(self) -> Param<Tensor<D>>

Fold parameter reparameterizations into their effective values and remove them.

fn train(self) -> Param<Tensor<D>>

Enables autodiff and restores configured training state throughout the module.

fn devices(&self) -> Vec<Device>

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

fn set_require_grad(self, require_grad: bool) -> Self

Set whether every floating-point tensor parameter in the module tree requires gradients.

fn set_require_grad_group(self, group: ParamGroup, require_grad: bool) -> Self

Set whether matched floating-point tensor parameters require gradients.

fn no_grad(self) -> Self

Disable gradients for every floating-point tensor parameter in the module tree.

fn freeze(self) -> Self

Freeze the whole module tree.

fn unfreeze(self) -> Self

Unfreeze the whole module tree.

fn freeze_group(self, group: ParamGroup) -> Self

Freeze every module-owned value in the given group, leaving the rest of the module untouched.

fn unfreeze_group(self, group: ParamGroup) -> Self

Unfreeze every module-owned value in the given group, leaving the rest of the module untouched.

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules, without initializing the ones not initialized yet.

fn quantize_weights(self, quantizer: &mut Quantizer) -> Self

Quantize the weights of the module.

fn quantize_weights_group( self, quantizer: &mut Quantizer, group: ParamGroup, ) -> Self

Quantize the weights of the given parameter group.

fn apply_reparameterization<R>(self, reparameterizer: R) -> Self

where Self: Sized, R: Reparameterizer,

Attach reparameterizations using the given Reparameterizer.

fn apply_lora(self, lora: Lora) -> Self

where Self: Sized,

Attach LoRA adapters to the module’s 2-D weights, freezing all base tensor parameters.

fn apply_qlora(self, qlora: QLora) -> Self

where Self: Sized,

Apply QLoRA to the module: quantize the (frozen) base tensor parameters and attach trainable LoRA adapters to 2-D weights.

fn into_record(self) -> ModuleRecord

where Self: Sized,

Collect this module’s tensor parameters into a ModuleRecord.

fn into_record_group(self, group: ParamGroup) -> ModuleRecord

where Self: Sized,

Collect the tensor parameters group names into a ModuleRecord.

fn try_load_record(self, record: ModuleRecord) -> Result<Self, RecordError>

where Self: Sized,

Apply a ModuleRecord to this module, returning the loaded module.

fn load_record(self, record: ModuleRecord) -> Self

where Self: Sized,

Apply a ModuleRecord to this module, consuming and returning it.

fn save_file<P>(self, path: P) -> Result<(), RecordError>

where P: AsRef<Path>, Self: Sized,

Save this module’s parameters to a burnpack file on disk.

fn load_file<P>(self, path: P) -> Self

where P: AsRef<Path>, Self: Sized,

Load this module’s parameters from a burnpack file on disk, returning the loaded module.

fn try_load_file<P>(self, path: P) -> Result<Self, RecordError>

where P: AsRef<Path>, Self: Sized,

Fallible variant of load_file.

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

fn materialize(self) -> Param<Tensor<D, Int>>

Fold parameter reparameterizations into their effective values and remove them.

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

where V: ModuleVisitor,

Visit each parameter and module-owned control value with a visitor.

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

where M: ModuleMapper,

Map each parameter and module-owned control value with a mapper.

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

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

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

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

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

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

fn valid(&self) -> Param<Tensor<D, Int>>

Returns a validation snapshot without autodiff or active training flags.

fn train(self) -> Param<Tensor<D, Int>>

Enables autodiff and restores configured training state throughout the module.

fn devices(&self) -> Vec<Device>

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

fn set_require_grad(self, require_grad: bool) -> Self

Set whether every floating-point tensor parameter in the module tree requires gradients.

fn set_require_grad_group(self, group: ParamGroup, require_grad: bool) -> Self

Set whether matched floating-point tensor parameters require gradients.

fn no_grad(self) -> Self

Disable gradients for every floating-point tensor parameter in the module tree.

fn freeze(self) -> Self

Freeze the whole module tree.

fn unfreeze(self) -> Self

Unfreeze the whole module tree.

fn freeze_group(self, group: ParamGroup) -> Self

Freeze every module-owned value in the given group, leaving the rest of the module untouched.

fn unfreeze_group(self, group: ParamGroup) -> Self

Unfreeze every module-owned value in the given group, leaving the rest of the module untouched.

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules, without initializing the ones not initialized yet.

fn quantize_weights(self, quantizer: &mut Quantizer) -> Self

Quantize the weights of the module.

fn quantize_weights_group( self, quantizer: &mut Quantizer, group: ParamGroup, ) -> Self

Quantize the weights of the given parameter group.

fn apply_reparameterization<R>(self, reparameterizer: R) -> Self

where Self: Sized, R: Reparameterizer,

Attach reparameterizations using the given Reparameterizer.

fn apply_lora(self, lora: Lora) -> Self

where Self: Sized,

Attach LoRA adapters to the module’s 2-D weights, freezing all base tensor parameters.

fn apply_qlora(self, qlora: QLora) -> Self

where Self: Sized,

Apply QLoRA to the module: quantize the (frozen) base tensor parameters and attach trainable LoRA adapters to 2-D weights.

fn into_record(self) -> ModuleRecord

where Self: Sized,

Collect this module’s tensor parameters into a ModuleRecord.

fn into_record_group(self, group: ParamGroup) -> ModuleRecord

where Self: Sized,

Collect the tensor parameters group names into a ModuleRecord.

fn try_load_record(self, record: ModuleRecord) -> Result<Self, RecordError>

where Self: Sized,

Apply a ModuleRecord to this module, returning the loaded module.

fn load_record(self, record: ModuleRecord) -> Self

where Self: Sized,

Apply a ModuleRecord to this module, consuming and returning it.

fn save_file<P>(self, path: P) -> Result<(), RecordError>

where P: AsRef<Path>, Self: Sized,

Save this module’s parameters to a burnpack file on disk.

fn load_file<P>(self, path: P) -> Self

where P: AsRef<Path>, Self: Sized,

Load this module’s parameters from a burnpack file on disk, returning the loaded module.

fn try_load_file<P>(self, path: P) -> Result<Self, RecordError>

where P: AsRef<Path>, Self: Sized,

Fallible variant of load_file.

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

fn materialize(self) -> Param<Tensor<D, Bool>>

Fold parameter reparameterizations into their effective values and remove them.

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

where V: ModuleVisitor,

Visit each parameter and module-owned control value with a visitor.

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

where M: ModuleMapper,

Map each parameter and module-owned control value with a mapper.

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

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

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

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

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

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

fn valid(&self) -> Param<Tensor<D, Bool>>

Returns a validation snapshot without autodiff or active training flags.

fn train(self) -> Param<Tensor<D, Bool>>

Enables autodiff and restores configured training state throughout the module.

fn devices(&self) -> Vec<Device>

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

fn set_require_grad(self, require_grad: bool) -> Self

Set whether every floating-point tensor parameter in the module tree requires gradients.

fn set_require_grad_group(self, group: ParamGroup, require_grad: bool) -> Self

Set whether matched floating-point tensor parameters require gradients.

fn no_grad(self) -> Self

Disable gradients for every floating-point tensor parameter in the module tree.

fn freeze(self) -> Self

Freeze the whole module tree.

fn unfreeze(self) -> Self

Unfreeze the whole module tree.

fn freeze_group(self, group: ParamGroup) -> Self

Freeze every module-owned value in the given group, leaving the rest of the module untouched.

fn unfreeze_group(self, group: ParamGroup) -> Self

Unfreeze every module-owned value in the given group, leaving the rest of the module untouched.

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules, without initializing the ones not initialized yet.

fn quantize_weights(self, quantizer: &mut Quantizer) -> Self

Quantize the weights of the module.

fn quantize_weights_group( self, quantizer: &mut Quantizer, group: ParamGroup, ) -> Self

Quantize the weights of the given parameter group.

fn apply_reparameterization<R>(self, reparameterizer: R) -> Self

where Self: Sized, R: Reparameterizer,

Attach reparameterizations using the given Reparameterizer.

fn apply_lora(self, lora: Lora) -> Self

where Self: Sized,

Attach LoRA adapters to the module’s 2-D weights, freezing all base tensor parameters.

fn apply_qlora(self, qlora: QLora) -> Self

where Self: Sized,

Apply QLoRA to the module: quantize the (frozen) base tensor parameters and attach trainable LoRA adapters to 2-D weights.

fn into_record(self) -> ModuleRecord

where Self: Sized,

Collect this module’s tensor parameters into a ModuleRecord.

fn into_record_group(self, group: ParamGroup) -> ModuleRecord

where Self: Sized,

Collect the tensor parameters group names into a ModuleRecord.

fn try_load_record(self, record: ModuleRecord) -> Result<Self, RecordError>

where Self: Sized,

Apply a ModuleRecord to this module, returning the loaded module.

fn load_record(self, record: ModuleRecord) -> Self

where Self: Sized,

Apply a ModuleRecord to this module, consuming and returning it.

fn save_file<P>(self, path: P) -> Result<(), RecordError>

where P: AsRef<Path>, Self: Sized,

Save this module’s parameters to a burnpack file on disk.

fn load_file<P>(self, path: P) -> Self

where P: AsRef<Path>, Self: Sized,

Load this module’s parameters from a burnpack file on disk, returning the loaded module.

fn try_load_file<P>(self, path: P) -> Result<Self, RecordError>

where P: AsRef<Path>, Self: Sized,

Fallible variant of load_file.

impl ModuleDisplay for Param<Flag>

fn format(&self, passed_settings: DisplaySettings) -> String

Formats the module with provided display settings.

fn custom_settings(&self) -> Option<DisplaySettings>

Custom display settings for the module.

fn custom_content(&self, _content: Content) -> Option<Content>

Custom attributes for the module.

impl<const D: usize> ModuleDisplay for Param<Tensor<D>>

fn format(&self, passed_settings: DisplaySettings) -> String

Formats the module with provided display settings.

fn custom_settings(&self) -> Option<DisplaySettings>

Custom display settings for the module.

fn custom_content(&self, _content: Content) -> Option<Content>

Custom attributes for the module.

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

fn format(&self, passed_settings: DisplaySettings) -> String

Formats the module with provided display settings.

fn custom_settings(&self) -> Option<DisplaySettings>

Custom display settings for the module.

fn custom_content(&self, _content: Content) -> Option<Content>

Custom attributes for the module.

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

fn format(&self, passed_settings: DisplaySettings) -> String

Formats the module with provided display settings.

fn custom_settings(&self) -> Option<DisplaySettings>

Custom display settings for the module.

fn custom_content(&self, _content: Content) -> Option<Content>

Custom attributes for the module.

impl ModuleDisplayDefault for Param<Flag>

fn content(&self, content: Content) -> Option<Content>

Attributes of the module used for display purposes.

fn num_params(&self) -> usize

Gets the number of the parameters of the module.

impl<const D: usize> ModuleDisplayDefault for Param<Tensor<D>>

fn content(&self, content: Content) -> Option<Content>

Attributes of the module used for display purposes.

fn num_params(&self) -> usize

Gets the number of the parameters of the module.

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

fn content(&self, content: Content) -> Option<Content>

Attributes of the module used for display purposes.

fn num_params(&self) -> usize

Gets the number of the parameters of the module.

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

fn content(&self, content: Content) -> Option<Content>

Attributes of the module used for display purposes.

fn num_params(&self) -> usize

Gets the number of the parameters of the module.