Struct burn::nn::interpolate::Interpolate2d

pub struct Interpolate2d {
    pub output_size: Option<[usize; 2]>,
    pub scale_factor: Option<[f32; 2]>,
    pub mode: Ignored<InterpolateMode>,
}

Interpolate module for resizing tensors with shape [N, C, H, W].

This struct represents an interpolation module that can resize tensors using various interpolation methods. It provides flexibility in specifying either an output size or a scale factor for resizing, along with options for the interpolation mode.

The module can be used to upsample or downsample tensors, preserving the number of channels and batch size while adjusting the height and width dimensions.

The module can be created using the Interpolate2dConfig struct and the init method, which returns an instance of the Interpolate2d struct.

Fields

output_size: Option<[usize; 2]>

Output size of the interpolated tensor

scale_factor: Option<[f32; 2]>

Scale factor for resizing the input tensor

mode: Ignored<InterpolateMode>

Interpolation mode used for resizing

Implementations

impl Interpolate2d

pub fn forward<B>(&self, input: Tensor<B, 4>) -> Tensor<B, 4>

where B: Backend,

Performs the forward pass of the interpolation module

Arguments

• input - Input tensor with shape [N, C, H, W]

Returns

Resized tensor with shape [N, C, H’, W’], where H’ and W’ are determined by the output_size or scale_factor specified in the module configuration

Example

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

Trait Implementations

impl<B> AutodiffModule<B> for Interpolate2d

where B: AutodiffBackend,

type InnerModule = Interpolate2d

Inner module without auto-differentiation.

fn valid(&self) -> <Interpolate2d as AutodiffModule<B>>::InnerModule

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

impl Clone for Interpolate2d

fn clone(&self) -> Interpolate2d

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Interpolate2d

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

Formats the value using the given formatter.

impl Display for Interpolate2d

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

Formats the value using the given formatter.

impl<B> Module<B> for Interpolate2d

where B: Backend,

type Record = ConstantRecord

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

where M: ModuleMapper<B>,

Map each tensor parameter in the module with a mapper.

fn load_record( self, _record: <Interpolate2d as Module<B>>::Record, ) -> Interpolate2d

Load the module state from a record.

fn into_record(self) -> <Interpolate2d as Module<B>>::Record

Convert the module into a record containing the state.

fn to_device(self, _: &<B as Backend>::Device) -> Interpolate2d

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

fn fork(self, _: &<B as Backend>::Device) -> Interpolate2d

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.

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

where C: Calibration,

Quantize the weights of the module.

impl ModuleDisplay for Interpolate2d

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.

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

Formats the module with provided display settings.

impl ModuleDisplayDefault for Interpolate2d

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.