Struct Wrapped 

pub struct Wrapped<W: Wrappable> { /* private fields */ }

wraps in a burn wrapper

Implementations

impl<A: AutodiffBackend<InnerBackend = B>, B: Backend, W, Y: 'static + ItemLazy + Send + Sync, Z: 'static + ItemLazy + Send + Sync> Wrapped<W>

where <Self as AutodiffModule<A>>::InnerModule: ValidStep<(Value<B>, Value<B>), Z>, Self: TrainStep<(Value<A>, Value<A>), Y>, W::Decomposition: AutodiffModule<A>, W::With<B>: Decompose<Decomposition = <W::Decomposition as AutodiffModule<A>>::InnerModule> + Op<Output = Z>, W: Op<Output = Y> + 'static + Wrappable<B = A>, Y::ItemSync: Adaptor<LossInput<NdArray>>, Z::ItemSync: Adaptor<LossInput<NdArray>>,

pub fn train<I: 'static + Clone + Debug + Into<(Value<A>, Value<A>)> + Send + Sync, J: 'static + Clone + Debug + Into<(Value<B>, Value<B>)> + Send + Sync, O: 'static + Optimizer<Self, A>, S: 'static + LrScheduler, T: 'static + Dataset<I>, V: 'static + Dataset<J>>( self, config: &TrainConfig, optimizer: O, scheduler: S, train: T, valid: V, ) -> Wrapped<W::With<B>>

where O::Record: 'static, S::Record<A>: 'static,

trains the model

impl<W: Wrappable> Wrapped<W>

pub fn inner(&self) -> &W

references the inner value

pub fn inner_mut(&mut self) -> &mut W

references the inner value

pub fn into_inner(self) -> W

unwraps the inner value

pub fn new(inner: W) -> Self

creates a new wrapped value

Trait Implementations

impl<W: AI<X, Y> + Wrappable, X, Y> AI<X, Y> for Wrapped<W>

fn forward(&self, input: X) -> Y

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<A: AutodiffBackend, W: Wrappable<B = A>> AutodiffModule<A> for Wrapped<W>

where W::Decomposition: AutodiffModule<A>, W::With<A::InnerBackend>: Decompose<Decomposition = <W::Decomposition as AutodiffModule<A>>::InnerModule>,

type InnerModule = Wrapped<<W as Wrappable>::With<<A as AutodiffBackend>::InnerBackend>>

Inner module without auto-differentiation.

fn valid(&self) -> Self::InnerModule

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

impl<W: Clone + Wrappable> Clone for Wrapped<W>

fn clone(&self) -> Wrapped<W>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<W: Debug + Wrappable> Debug for Wrapped<W>

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

Formats the value using the given formatter.

impl<W: Wrappable> Decompose for Wrapped<W>

type Decomposition = <W as Decompose>::Decomposition

the decomposed type

fn compose(decomposition: Self::Decomposition) -> Self

recreates from the decomposition

fn decompose(self) -> Self::Decomposition

owned decomposition

fn decompose_cloned(&self) -> Self::Decomposition

decomposition that copies data

impl<W: Default + Wrappable> Default for Wrapped<W>

fn default() -> Wrapped<W>

Returns the “default value” for a type.

impl<W: Wrappable> Display for Wrapped<W>

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

Formats the value using the given formatter.

impl<W: Wrappable> From<W> for Wrapped<W>

fn from(value: W) -> Self

Converts to this type from the input type.

impl<B: Backend, W: Wrappable<B = B>> Module<B> for Wrapped<W>

where W::Decomposition: Module<B>,

type Record = <<W as Decompose>::Decomposition as Module<B>>::Record

Type to save and load the module.

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 fork(self, device: &<B as Backend>::Device) -> Self

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

fn into_record(self) -> Self::Record

Convert the module into a record containing the state.

fn load_file<F: FileRecorder<B>, P: Into<PathBuf>>( self, filepath: P, recorder: &F, device: &<B as Backend>::Device, ) -> Result<Self, RecorderError>

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

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

Load the module state from a record.

fn map<Mapper: ModuleMapper<B>>(self, mapper: &mut Mapper) -> Self

Map each tensor parameter in the module with a mapper.

fn num_params(&self) -> usize

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

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

Quantize the weights of the module.

fn save_file<F: FileRecorder<B>, P: Into<PathBuf>>( self, filepath: P, recorder: &F, ) -> Result<(), RecorderError>

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

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

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

fn visit<Visitor: ModuleVisitor<B>>(&self, visitor: &mut Visitor)

Visit each tensor parameter in the module with a visitor.

fn no_grad(self) -> Self

Each tensor in the module tree will not require grad.

impl<W: Wrappable> ModuleDisplay for Wrapped<W>

where W::Decomposition: ModuleDisplay,

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

Custom attributes for the module.

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

Custom display settings for the module.

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

Formats the module with provided display settings.

impl<W: Wrappable> ModuleDisplayDefault for Wrapped<W>

where W::Decomposition: ModuleDisplayDefault,

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<W: Op + Wrappable> Op for Wrapped<W>

type Output = <W as Op>::Output

suggested output type to help with composition coherence. Ideally, Self should implement AI<X,Self::Output> for some X

fn abnormal_softmax(self, temperature: f32) -> AbnormalSoftmax<Self>

where Self: Sized, AbnormalSoftmax<Self>: Op,

wraps with a softmax operation

fn abs(self) -> Abs<Self>

where Self: Sized, Abs<Self>: Op,

wraps with an absolute value operation

fn acc_q(self, gamma: f32) -> AccQ<Self>

where AccQ<Self>: Op, Self: Sized,

wraps with a accq operation

fn cat(self, dim: i32) -> Cat<Self>

where Cat<Self>: Op, Self: Sized,

wraps with a cat operation

fn chain<B>(self, b: B) -> Sequential<(Self, B)>

where Self: Sized, Sequential<(Self, B)>: Op,

sequences with another ai operation

fn cross_entropy(self, temperature: f32) -> CrossEntropy<Self>

where CrossEntropy<Self>: Op, Self: Sized,

wraps with a cross entropy operation. If temperature is a number it will be used to apply softmax to the logits before computing entropy with the target. if the input will already be a probability distribution instead of logits, put NaN temperature

fn duplicate(self) -> Duplicate<Self>

where Duplicate<Self>: Op, Self: Sized,

wraps with a duplicate operation

fn fix_type<Z>(self) -> SetType<Self, Z, Z>

where Self: AI<Z, Z> + Sized,

set type but with the same input and output

fn flatten<R: Clone>(self, args: R) -> Flatten<Self, R>

where Flatten<Self, R>: Op, Self: Sized,

wraps with a flatten layer

fn forward_fixed<Z>(&self, input: Z) -> Z

where Self: AI<Z, Z> + Sized,

applies to the input

fn forward_fixed_mut<Z>(&mut self, input: Z) -> Z

where Self: AI<Z, Z> + Sized,

applies to the input

fn forward_typed<W, Z>(&self, input: W) -> Z

where Self: AI<W, Z> + Sized,

applies to the input

fn forward_typed_mut<W, Z>(&mut self, input: W) -> Z

where Self: AI<W, Z> + Sized,

applies to the input, possibly updating internal caches

fn infer_autoregressive<X, Y>(self, input: X) -> Autoregression<Self, Y>

where Self: AI<X, Y> + AI<Y, Y> + Sized, Y: Clone,

creates an autoregressive inference

fn log_softmax(self, temperature: f32) -> LogSoftmax<Self>

where Self: Sized, LogSoftmax<Self>: Op,

wraps with a softmax operation

fn map<B>(self, b: B) -> Map<Sequential<(Self, B)>>

where Map<Sequential<(Self, B)>>: Op, Self: Sized, Sequential<(Self, B)>: Op,

applies the operation to every output

fn mean(self) -> Mean<Self>

where Mean<Self>: Op, Self: Sized,

wraps with a mean operation

fn optional(self) -> Option<Self>

where Self: Sized,

creates an optional operation

fn reshape<R: Clone>(self, args: R) -> Reshape<Self, R>

where Reshape<Self, R>: Op, Self: Sized,

wraps with a reshape layer

fn residual(self) -> Residual<Self>

where Residual<Self>: Op, Self: Sized,

wraps in a residual layer

fn set_type<W, Z>(self) -> SetType<Self, W, Z>

where Self: AI<W, Z> + Sized,

sets the input output types

fn soft_choose(self, temperature: f32) -> Choose<Self>

where Self: Sized, Choose<Self>: Op,

wraps with a choose operation

fn softmax(self, temperature: f32) -> Softmax<Self>

where Self: Sized, Softmax<Self>: Op,

wraps with a softmax operation

fn squared_error(self) -> SquaredError<Self>

where SquaredError<Self>: Op, Self: Sized,

wraps with a mse operation

fn squeeze(self, dim: i32) -> Squeeze<Self>

where Squeeze<Self>: Op, Self: Sized,

wraps with a squeeze operation

fn stack(self, dim: i32) -> Stack<Self>

where Stack<Self>: Op, Self: Sized,

wraps with a stack operation

fn to_each(self) -> Map<Self>

where Map<Self>: Op, Self: Sized,

wraps with a map operation

fn unsqueeze(self, dim: i32) -> Unsqueeze<Self>

where Unsqueeze<Self>: Op, Self: Sized,

wraps with a unsqueeze operation

fn sum(self) -> Sum<Self>

where Sum<Self>: Op, Self: Sized,

wraps with a sum operation

fn wrap_inner(self) -> Inner<Self>

where Self: Sized,

wraps the inner value so it can be unwrapped with unwrap inner

fn zip<B>(self, b: B) -> Zip<(Self, B)>

where Self: Sized, Zip<(Self, B)>: Op,

zips with another ai operation

impl<C: Backend, W: ToBackend<C, OnBackend = W::With<C>> + Wrappable> ToBackend<C> for Wrapped<W>

type OnBackend = Wrapped<<W as Wrappable>::With<C>>

the type on the new backend

fn to_backend_device(self, device: &C::Device) -> Self::OnBackend

moves the module to the backend with the device

fn to_backend(self) -> Self::OnBackend

moves the module to the backend with the device

impl<A: AutodiffBackend, W: AI<X, LossOutput<A>> + Wrappable<B = A>, X> TrainStep<X, ClassificationOutput<A>> for Wrapped<Classification<W>>

where W::Decomposition: AutodiffModule<A>, W::With<A::InnerBackend>: Decompose<Decomposition = <W::Decomposition as AutodiffModule<A>>::InnerModule>,

fn step(&self, item: X) -> TrainOutput<ClassificationOutput<A>>

Runs the training step, which executes the forward and backward passes.

fn optimize<B, O>(self, optim: &mut O, lr: f64, grads: GradientsParams) -> Self

where B: AutodiffBackend, O: Optimizer<Self, B>, Self: AutodiffModule<B>,

Optimize the current module with the provided gradients and learning rate.

impl<A: AutodiffBackend, W: AI<X, LossOutput<A>> + Wrappable<B = A>, X> TrainStep<X, RegressionOutput<A>> for Wrapped<Regression<W>>

where W::Decomposition: AutodiffModule<A>, W::With<A::InnerBackend>: Decompose<Decomposition = <W::Decomposition as AutodiffModule<A>>::InnerModule>,

fn step(&self, item: X) -> TrainOutput<RegressionOutput<A>>

Runs the training step, which executes the forward and backward passes.

fn optimize<B, O>(self, optim: &mut O, lr: f64, grads: GradientsParams) -> Self

where B: AutodiffBackend, O: Optimizer<Self, B>, Self: AutodiffModule<B>,

Optimize the current module with the provided gradients and learning rate.

impl<W: UnwrapInner + Wrappable> UnwrapInner for Wrapped<W>

type Inner = <W as UnwrapInner>::Inner

the inner type

fn unwrap_inner(self) -> Self::Inner

unwraps the inner value

impl<B: Backend, W: AI<X, LossOutput<B>> + Wrappable<B = B>, X> ValidStep<X, ClassificationOutput<B>> for Wrapped<Classification<W>>

where W::Decomposition: Module<B>,

fn step(&self, item: X) -> ClassificationOutput<B>

Runs a validation step.

impl<B: Backend, W: AI<X, LossOutput<B>> + Wrappable<B = B>, X> ValidStep<X, RegressionOutput<B>> for Wrapped<Regression<W>>

where W::Decomposition: Module<B>,

fn step(&self, item: X) -> RegressionOutput<B>

Runs a validation step.

impl<W: Copy + Wrappable> Copy for Wrapped<W>