Trait burn::record::Record

pub trait Record<B>: Sendwhere
    B: Backend,{
    type Item<S: PrecisionSettings>: Serialize + DeserializeOwned;

    // Required methods
    fn into_item<S>(self) -> Self::Item<S>
       where S: PrecisionSettings;
    fn from_item<S>(
        item: Self::Item<S>,
        device: &<B as Backend>::Device,
    ) -> Self
       where S: PrecisionSettings;
}

Expand description

Trait to define a family of types which can be recorded using any settings.

Required Associated Types§

type Item<S: PrecisionSettings>: Serialize + DeserializeOwned

Type of the item that can be serialized and deserialized.

Required Methods§

fn into_item<S>(self) -> Self::Item<S>
where S: PrecisionSettings,

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

fn from_item<S>(item: Self::Item<S>, device: &::Device) -> Self
where S: PrecisionSettings,

Convert the given item into a record.

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

§

fn from_item<S>( item: <bool as Record>::Item<S>, _device: &::Device, ) -> bool
where S: PrecisionSettings,

§

impl Record for f32
where B: Backend,

§

type Item<S: PrecisionSettings> = f32

§

fn into_item<S>(self) -> <f32 as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <f32 as Record>::Item<S>, _device: &::Device, ) -> f32
where S: PrecisionSettings,

§

impl Record for f64
where B: Backend,

§

type Item<S: PrecisionSettings> = f64

§

fn into_item<S>(self) -> <f64 as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <f64 as Record>::Item<S>, _device: &::Device, ) -> f64
where S: PrecisionSettings,

§

impl Record for i8
where B: Backend,

§

type Item<S: PrecisionSettings> = i8

§

fn into_item<S>(self) -> <i8 as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <i8 as Record>::Item<S>, _device: &::Device, ) -> i8
where S: PrecisionSettings,

§

impl Record for i16
where B: Backend,

§

type Item<S: PrecisionSettings> = i16

§

fn into_item<S>(self) -> <i16 as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <i16 as Record>::Item<S>, _device: &::Device, ) -> i16
where S: PrecisionSettings,

§

impl Record for i32
where B: Backend,

§

type Item<S: PrecisionSettings> = i32

§

fn into_item<S>(self) -> <i32 as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <i32 as Record>::Item<S>, _device: &::Device, ) -> i32
where S: PrecisionSettings,

§

impl Record for i64
where B: Backend,

§

type Item<S: PrecisionSettings> = i64

§

fn into_item<S>(self) -> <i64 as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <i64 as Record>::Item<S>, _device: &::Device, ) -> i64
where S: PrecisionSettings,

§

impl Record for u8
where B: Backend,

§

type Item<S: PrecisionSettings> = u8

§

fn into_item<S>(self) -> <u8 as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <u8 as Record>::Item<S>, _device: &::Device, ) -> u8
where S: PrecisionSettings,

§

impl Record for u16
where B: Backend,

§

type Item<S: PrecisionSettings> = u16

§

fn into_item<S>(self) -> <u16 as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <u16 as Record>::Item<S>, _device: &::Device, ) -> u16
where S: PrecisionSettings,

§

impl Record for u32
where B: Backend,

§

type Item<S: PrecisionSettings> = u32

§

fn into_item<S>(self) -> <u32 as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <u32 as Record>::Item<S>, _device: &::Device, ) -> u32
where S: PrecisionSettings,

§

impl Record for u64
where B: Backend,

§

type Item<S: PrecisionSettings> = u64

§

fn into_item<S>(self) -> <u64 as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <u64 as Record>::Item<S>, _device: &::Device, ) -> u64
where S: PrecisionSettings,

§

impl Record for ()
where B: Backend,

§

type Item<S: PrecisionSettings> = ()

§

fn into_item<S>(self) -> <() as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( _item: <() as Record>::Item<S>, _device: &::Device, )
where S: PrecisionSettings,

§

impl Record for usize
where B: Backend,

§

type Item<S: PrecisionSettings> = usize

§

fn into_item<S>(self) -> <usize as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <usize as Record>::Item<S>, _device: &::Device, ) -> usize
where S: PrecisionSettings,

§

impl Record for String
where B: Backend,

§

type Item<S: PrecisionSettings> = String

§

fn into_item<S>(self) -> <String as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <String as Record>::Item<S>, _device: &::Device, ) -> String
where S: PrecisionSettings,

§

impl<B, R0, R1> Record for (R0, R1)
where B: Backend, R0: Record, R1: Record,

§

type Item<S: PrecisionSettings> = (<R0 as Record>::Item<S>, <R1 as Record>::Item<S>)

§

fn into_item<S>(self) -> <(R0, R1) as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <(R0, R1) as Record>::Item<S>, device: &::Device, ) -> (R0, R1)
where S: PrecisionSettings,

§

impl<B, R0, R1, R2> Record for (R0, R1, R2)
where B: Backend, R0: Record, R1: Record, R2: Record,

§

type Item<S: PrecisionSettings> = (<R0 as Record>::Item<S>, <R1 as Record>::Item<S>, <R2 as Record>::Item<S>)

§

fn into_item<S>(self) -> <(R0, R1, R2) as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <(R0, R1, R2) as Record>::Item<S>, device: &::Device, ) -> (R0, R1, R2)
where S: PrecisionSettings,

§

impl<B, R0, R1, R2, R3> Record for (R0, R1, R2, R3)
where B: Backend, R0: Record, R1: Record, R2: Record, R3: Record,

§

type Item<S: PrecisionSettings> = (<R0 as Record>::Item<S>, <R1 as Record>::Item<S>, <R2 as Record>::Item<S>, <R3 as Record>::Item<S>)

§

fn into_item<S>(self) -> <(R0, R1, R2, R3) as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <(R0, R1, R2, R3) as Record>::Item<S>, device: &::Device, ) -> (R0, R1, R2, R3)
where S: PrecisionSettings,

§

impl<B, R0, R1, R2, R3, R4> Record for (R0, R1, R2, R3, R4)
where B: Backend, R0: Record, R1: Record, R2: Record, R3: Record, R4: Record,

§

type Item<S: PrecisionSettings> = (<R0 as Record>::Item<S>, <R1 as Record>::Item<S>, <R2 as Record>::Item<S>, <R3 as Record>::Item<S>, <R4 as Record>::Item<S>)

§

fn into_item<S>(self) -> <(R0, R1, R2, R3, R4) as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <(R0, R1, R2, R3, R4) as Record>::Item<S>, device: &::Device, ) -> (R0, R1, R2, R3, R4)
where S: PrecisionSettings,

§

impl<B, R0, R1, R2, R3, R4, R5> Record for (R0, R1, R2, R3, R4, R5)
where B: Backend, R0: Record, R1: Record, R2: Record, R3: Record, R4: Record, R5: Record,

§

type Item<S: PrecisionSettings> = (<R0 as Record>::Item<S>, <R1 as Record>::Item<S>, <R2 as Record>::Item<S>, <R3 as Record>::Item<S>, <R4 as Record>::Item<S>, <R5 as Record>::Item<S>)

§

fn into_item<S>(self) -> <(R0, R1, R2, R3, R4, R5) as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <(R0, R1, R2, R3, R4, R5) as Record>::Item<S>, device: &::Device, ) -> (R0, R1, R2, R3, R4, R5)
where S: PrecisionSettings,

§

impl<B, R0, R1, R2, R3, R4, R5, R6> Record for (R0, R1, R2, R3, R4, R5, R6)
where B: Backend, R0: Record, R1: Record, R2: Record, R3: Record, R4: Record, R5: Record, R6: Record,

§

type Item<S: PrecisionSettings> = (<R0 as Record>::Item<S>, <R1 as Record>::Item<S>, <R2 as Record>::Item<S>, <R3 as Record>::Item<S>, <R4 as Record>::Item<S>, <R5 as Record>::Item<S>, <R6 as Record>::Item<S>)

§

fn into_item<S>(self) -> <(R0, R1, R2, R3, R4, R5, R6) as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <(R0, R1, R2, R3, R4, R5, R6) as Record>::Item<S>, device: &::Device, ) -> (R0, R1, R2, R3, R4, R5, R6)
where S: PrecisionSettings,

§

impl<B, R0, R1, R2, R3, R4, R5, R6, R7> Record for (R0, R1, R2, R3, R4, R5, R6, R7)
where B: Backend, R0: Record, R1: Record, R2: Record, R3: Record, R4: Record, R5: Record, R6: Record, R7: Record,

§

type Item<S: PrecisionSettings> = (<R0 as Record>::Item<S>, <R1 as Record>::Item<S>, <R2 as Record>::Item<S>, <R3 as Record>::Item<S>, <R4 as Record>::Item<S>, <R5 as Record>::Item<S>, <R6 as Record>::Item<S>, <R7 as Record>::Item<S>)

§

fn into_item<S>( self, ) -> <(R0, R1, R2, R3, R4, R5, R6, R7) as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <(R0, R1, R2, R3, R4, R5, R6, R7) as Record>::Item<S>, device: &::Device, ) -> (R0, R1, R2, R3, R4, R5, R6, R7)
where S: PrecisionSettings,

§

impl<B, R0, R1, R2, R3, R4, R5, R6, R7, R8> Record for (R0, R1, R2, R3, R4, R5, R6, R7, R8)
where B: Backend, R0: Record, R1: Record, R2: Record, R3: Record, R4: Record, R5: Record, R6: Record, R7: Record, R8: Record,

§

type Item<S: PrecisionSettings> = (<R0 as Record>::Item<S>, <R1 as Record>::Item<S>, <R2 as Record>::Item<S>, <R3 as Record>::Item<S>, <R4 as Record>::Item<S>, <R5 as Record>::Item<S>, <R6 as Record>::Item<S>, <R7 as Record>::Item<S>, <R8 as Record>::Item<S>)

§

fn into_item<S>( self, ) -> <(R0, R1, R2, R3, R4, R5, R6, R7, R8) as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <(R0, R1, R2, R3, R4, R5, R6, R7, R8) as Record>::Item<S>, device: &::Device, ) -> (R0, R1, R2, R3, R4, R5, R6, R7, R8)
where S: PrecisionSettings,

§

impl<B, R0, R1, R2, R3, R4, R5, R6, R7, R8, R9> Record for (R0, R1, R2, R3, R4, R5, R6, R7, R8, R9)
where B: Backend, R0: Record, R1: Record, R2: Record, R3: Record, R4: Record, R5: Record, R6: Record, R7: Record, R8: Record, R9: Record,

§

type Item<S: PrecisionSettings> = (<R0 as Record>::Item<S>, <R1 as Record>::Item<S>, <R2 as Record>::Item<S>, <R3 as Record>::Item<S>, <R4 as Record>::Item<S>, <R5 as Record>::Item<S>, <R6 as Record>::Item<S>, <R7 as Record>::Item<S>, <R8 as Record>::Item<S>, <R9 as Record>::Item<S>)

§

fn into_item<S>( self, ) -> <(R0, R1, R2, R3, R4, R5, R6, R7, R8, R9) as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <(R0, R1, R2, R3, R4, R5, R6, R7, R8, R9) as Record>::Item<S>, device: &::Device, ) -> (R0, R1, R2, R3, R4, R5, R6, R7, R8, R9)
where S: PrecisionSettings,

§

impl<T, B> Record for Option<T>
where T: Record, B: Backend,

§

type Item<S: PrecisionSettings> = Option<<T as Record>::Item<S>>

§

fn into_item<S>(self) -> <Option<T> as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <Option<T> as Record>::Item<S>, device: &::Device, ) -> Option<T>
where S: PrecisionSettings,

§

impl<T, B> Record for Vec<T>
where T: Record, B: Backend,

§

type Item<S: PrecisionSettings> = Vec<<T as Record>::Item<S>>

§

fn into_item<S>(self) -> <Vec<T> as Record>::Item<S> ⓘ
where S: PrecisionSettings,

§

fn from_item<S>( item: <Vec<T> as Record>::Item<S>, device: &::Device, ) -> Vec<T>
where S: PrecisionSettings,

§

impl<T, B> Record for HashMap<ParamId, T>
where T: Record, B: Backend,

§

type Item<S: PrecisionSettings> = HashMap<String, <T as Record>::Item<S>>

§

fn into_item<S>(self) -> <HashMap<ParamId, T> as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <HashMap<ParamId, T> as Record>::Item<S>, device: &::Device, ) -> HashMap<ParamId, T>
where S: PrecisionSettings,

§

impl<const N: usize, T, B> Record for [T; N]
where T: Record, B: Backend,

§

type Item<S: PrecisionSettings> = Array<N, <T as Record>::Item<S>>

The record item is an array of the record item of the elements. The reason why we wrap the array in a struct is because serde does not support deserializing arrays of variable size, see serde/issues/1937. for backward compatibility reasons. Serde APIs were created before const generics.

§

fn into_item<S>(self) -> <[T; N] as Record>::Item<S>
where S: PrecisionSettings,

§

fn from_item<S>( item: <[T; N] as Record>::Item<S>, device: &::Device, ) -> [T; N]
where S: PrecisionSettings,

Implementors§

§

impl Record for ConstantRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = ConstantRecord

§

impl Record for MultiHeadAttentionRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = MultiHeadAttentionRecordItem<B, S>

§

impl Record for Conv1dRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = Conv1dRecordItem<B, S>

§

impl Record for Conv2dRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = Conv2dRecordItem<B, S>

§

impl Record for Conv3dRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = Conv3dRecordItem<B, S>

§

impl Record for ConvTranspose1dRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = ConvTranspose1dRecordItem<B, S>

§

impl Record for ConvTranspose2dRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = ConvTranspose2dRecordItem<B, S>

§

impl Record for ConvTranspose3dRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = ConvTranspose3dRecordItem<B, S>

§

impl Record for DeformConv2dRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = DeformConv2dRecordItem<B, S>

§

impl Record for GruRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = GruRecordItem<B, S>

§

impl Record for BinaryCrossEntropyLossRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = BinaryCrossEntropyLossRecordItem<B, S>

§

impl Record for CrossEntropyLossRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = CrossEntropyLossRecordItem<B, S>

§

impl Record for BiLstmRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = BiLstmRecordItem<B, S>

§

impl Record for EmbeddingRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = EmbeddingRecordItem<B, S>

§

impl Record for GateControllerRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = GateControllerRecordItem<B, S>

§

impl Record for GroupNormRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = GroupNormRecordItem<B, S>

§

impl Record for InstanceNormRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = InstanceNormRecordItem<B, S>

§

impl Record for LayerNormRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = LayerNormRecordItem<B, S>

§

impl Record for LinearRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = LinearRecordItem<B, S>

§

impl Record for LstmRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = LstmRecordItem<B, S>

§

impl Record for PReluRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = PReluRecordItem<B, S>

§

impl Record for PositionalEncodingRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = PositionalEncodingRecordItem<B, S>

§

impl Record for RmsNormRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = RmsNormRecordItem<B, S>

§

impl Record for RotaryEncodingRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = RotaryEncodingRecordItem<B, S>

§

impl Record for SwiGluRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = SwiGluRecordItem<B, S>

§

impl Record for PositionWiseFeedForwardRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = PositionWiseFeedForwardRecordItem<B, S>

§

impl Record for TransformerDecoderLayerRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = TransformerDecoderLayerRecordItem<B, S>

§

impl Record for TransformerDecoderRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = TransformerDecoderRecordItem<B, S>

§

impl Record for TransformerEncoderLayerRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = TransformerEncoderLayerRecordItem<B, S>

§

impl Record for TransformerEncoderRecord
where B: Backend,

§

type Item<S: PrecisionSettings> = TransformerEncoderRecordItem<B, S>

§

impl Record for bf16
where B: Backend,

§

type Item<S: PrecisionSettings> = bf16

§

impl Record for f16
where B: Backend,

§

type Item<S: PrecisionSettings> = f16

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<B, const D: usize> Record for BatchNormRecord<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = BatchNormRecordItem<B, D, S>

§

impl<B, const D: usize> Record for WeightDecayState<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = WeightDecayStateItem<B, D, S>

§

impl<B, const D: usize> Record for MomentumState<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = MomentumStateItem<B, D, S>

§

impl<B, const D: usize> Record for AdaGradState<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = AdaGradStateItem<B, D, S>

§

impl<B, const D: usize> Record for AdamState<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = AdamStateItem<B, D, S>

§

impl<B, const D: usize> Record for AdamWState<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = AdamWStateItem<B, D, S>

§

impl<B, const D: usize> Record for AdaptiveMomentumState<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = AdaptiveMomentumStateItem<B, D, S>

§

impl<B, const D: usize> Record for AdaptiveMomentumWState<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = AdaptiveMomentumWStateItem<B, D, S>

§

impl<B, const D: usize> Record for CenteredState<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = CenteredStateItem<B, D, S>

§

impl<B, const D: usize> Record for LrDecayState<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = LrDecayStateItem<B, D, S>

§

impl<B, const D: usize> Record for RmsPropMomentumState<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = RmsPropMomentumStateItem<B, D, S>

§

impl<B, const D: usize> Record for RmsPropState<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = RmsPropStateItem<B, D, S>

§

impl<B, const D: usize> Record for SgdState<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = SgdStateItem<B, D, S>

§

impl<B, const D: usize> Record for SquareAvgState<B, D>
where B: Backend,

§

type Item<S: PrecisionSettings> = SquareAvgStateItem<B, D, S>

§

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

§

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

§

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

§

type Item<S: PrecisionSettings> = BoolTensorSerde

§

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

§

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

§

impl<E, B> Record for DataSerialize<E>
where E: Element, B: Backend,

§

type Item<S: PrecisionSettings> = DataSerialize<<S as PrecisionSettings>::FloatElem>

§

impl<O, B> Record for AdaptorRecord<O, B>
where O: SimpleOptimizer<::InnerBackend>, B: AutodiffBackend,

§

type Item<S: PrecisionSettings> = AdaptorRecordItem<O, B, S>

§

impl<O, B> Record for AdaptorRecordV1<O, B>
where O: SimpleOptimizer, B: Backend,

§

Trait burn::record::RecordCopy item path

Required Associated Types§

type Item<S: PrecisionSettings>: Serialize + DeserializeOwned

Required Methods§

fn into_item<S>(self) -> Self::Item<S>where S: PrecisionSettings,

fn from_item<S>(item: Self::Item<S>, device: &<B as Backend>::Device) -> Selfwhere S: PrecisionSettings,

Object Safety§

Implementations on Foreign Types§

impl<B> Record<B> for boolwhere B: Backend,

type Item<S: PrecisionSettings> = bool

fn into_item<S>(self) -> <bool as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <bool as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> boolwhere S: PrecisionSettings,

impl<B> Record<B> for f32where B: Backend,

type Item<S: PrecisionSettings> = f32

fn into_item<S>(self) -> <f32 as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <f32 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> f32where S: PrecisionSettings,

impl<B> Record<B> for f64where B: Backend,

type Item<S: PrecisionSettings> = f64

fn into_item<S>(self) -> <f64 as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <f64 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> f64where S: PrecisionSettings,

impl<B> Record<B> for i8where B: Backend,

type Item<S: PrecisionSettings> = i8

fn into_item<S>(self) -> <i8 as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <i8 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> i8where S: PrecisionSettings,

impl<B> Record<B> for i16where B: Backend,

type Item<S: PrecisionSettings> = i16

fn into_item<S>(self) -> <i16 as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <i16 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> i16where S: PrecisionSettings,

impl<B> Record<B> for i32where B: Backend,

type Item<S: PrecisionSettings> = i32

fn into_item<S>(self) -> <i32 as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <i32 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> i32where S: PrecisionSettings,

impl<B> Record<B> for i64where B: Backend,

type Item<S: PrecisionSettings> = i64

fn into_item<S>(self) -> <i64 as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <i64 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> i64where S: PrecisionSettings,

impl<B> Record<B> for u8where B: Backend,

type Item<S: PrecisionSettings> = u8

fn into_item<S>(self) -> <u8 as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <u8 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> u8where S: PrecisionSettings,

impl<B> Record<B> for u16where B: Backend,

type Item<S: PrecisionSettings> = u16

fn into_item<S>(self) -> <u16 as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <u16 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> u16where S: PrecisionSettings,

impl<B> Record<B> for u32where B: Backend,

type Item<S: PrecisionSettings> = u32

fn into_item<S>(self) -> <u32 as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <u32 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> u32where S: PrecisionSettings,

impl<B> Record<B> for u64where B: Backend,

type Item<S: PrecisionSettings> = u64

fn into_item<S>(self) -> <u64 as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <u64 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> u64where S: PrecisionSettings,

impl<B> Record<B> for ()where B: Backend,

type Item<S: PrecisionSettings> = ()

fn into_item<S>(self) -> <() as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( _item: <() as Record<B>>::Item<S>, _device: &<B as Backend>::Device, )where S: PrecisionSettings,

impl<B> Record<B> for usizewhere B: Backend,

type Item<S: PrecisionSettings> = usize

fn into_item<S>(self) -> <usize as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <usize as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> usizewhere S: PrecisionSettings,

impl<B> Record<B> for Stringwhere B: Backend,

type Item<S: PrecisionSettings> = String

fn into_item<S>(self) -> <String as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <String as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> Stringwhere S: PrecisionSettings,

impl<B, R0, R1> Record<B> for (R0, R1)where B: Backend, R0: Record<B>, R1: Record<B>,

type Item<S: PrecisionSettings> = (<R0 as Record<B>>::Item<S>, <R1 as Record<B>>::Item<S>)

fn into_item<S>(self) -> <(R0, R1) as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <(R0, R1) as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> (R0, R1)where S: PrecisionSettings,

impl<B, R0, R1, R2> Record<B> for (R0, R1, R2)where B: Backend, R0: Record<B>, R1: Record<B>, R2: Record<B>,

type Item<S: PrecisionSettings> = (<R0 as Record<B>>::Item<S>, <R1 as Record<B>>::Item<S>, <R2 as Record<B>>::Item<S>)

fn into_item<S>(self) -> <(R0, R1, R2) as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <(R0, R1, R2) as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> (R0, R1, R2)where S: PrecisionSettings,

impl<B, R0, R1, R2, R3> Record<B> for (R0, R1, R2, R3)where B: Backend, R0: Record<B>, R1: Record<B>, R2: Record<B>, R3: Record<B>,

type Item<S: PrecisionSettings> = (<R0 as Record<B>>::Item<S>, <R1 as Record<B>>::Item<S>, <R2 as Record<B>>::Item<S>, <R3 as Record<B>>::Item<S>)

fn into_item<S>(self) -> <(R0, R1, R2, R3) as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <(R0, R1, R2, R3) as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> (R0, R1, R2, R3)where S: PrecisionSettings,

impl<B, R0, R1, R2, R3, R4> Record<B> for (R0, R1, R2, R3, R4)where B: Backend, R0: Record<B>, R1: Record<B>, R2: Record<B>, R3: Record<B>, R4: Record<B>,

type Item<S: PrecisionSettings> = (<R0 as Record<B>>::Item<S>, <R1 as Record<B>>::Item<S>, <R2 as Record<B>>::Item<S>, <R3 as Record<B>>::Item<S>, <R4 as Record<B>>::Item<S>)

fn into_item<S>(self) -> <(R0, R1, R2, R3, R4) as Record<B>>::Item<S>where S: PrecisionSettings,

fn from_item<S>( item: <(R0, R1, R2, R3, R4) as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> (R0, R1, R2, R3, R4)where S: PrecisionSettings,

Trait burn::record::Record

fn into_item<S>(self) -> Self::Item<S>
where S: PrecisionSettings,

fn from_item<S>(item: Self::Item<S>, device: &<B as Backend>::Device) -> Self
where S: PrecisionSettings,

impl<B> Record<B> for bool
where B: Backend,

fn into_item<S>(self) -> <bool as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <bool as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> bool
where S: PrecisionSettings,

impl<B> Record<B> for f32
where B: Backend,

fn into_item<S>(self) -> <f32 as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <f32 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> f32
where S: PrecisionSettings,

impl<B> Record<B> for f64
where B: Backend,

fn into_item<S>(self) -> <f64 as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <f64 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> f64
where S: PrecisionSettings,

impl<B> Record<B> for i8
where B: Backend,

fn into_item<S>(self) -> <i8 as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <i8 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> i8
where S: PrecisionSettings,

impl<B> Record<B> for i16
where B: Backend,

fn into_item<S>(self) -> <i16 as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <i16 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> i16
where S: PrecisionSettings,

impl<B> Record<B> for i32
where B: Backend,

fn into_item<S>(self) -> <i32 as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <i32 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> i32
where S: PrecisionSettings,

impl<B> Record<B> for i64
where B: Backend,

fn into_item<S>(self) -> <i64 as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <i64 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> i64
where S: PrecisionSettings,

impl<B> Record<B> for u8
where B: Backend,

fn into_item<S>(self) -> <u8 as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <u8 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> u8
where S: PrecisionSettings,

impl<B> Record<B> for u16
where B: Backend,

fn into_item<S>(self) -> <u16 as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <u16 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> u16
where S: PrecisionSettings,

impl<B> Record<B> for u32
where B: Backend,

fn into_item<S>(self) -> <u32 as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <u32 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> u32
where S: PrecisionSettings,

impl<B> Record<B> for u64
where B: Backend,

fn into_item<S>(self) -> <u64 as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <u64 as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> u64
where S: PrecisionSettings,

impl<B> Record<B> for ()
where B: Backend,

fn into_item<S>(self) -> <() as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( _item: <() as Record<B>>::Item<S>, _device: &<B as Backend>::Device, )
where S: PrecisionSettings,

impl<B> Record<B> for usize
where B: Backend,

fn into_item<S>(self) -> <usize as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <usize as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> usize
where S: PrecisionSettings,

impl<B> Record<B> for String
where B: Backend,

fn into_item<S>(self) -> <String as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <String as Record<B>>::Item<S>, _device: &<B as Backend>::Device, ) -> String
where S: PrecisionSettings,

impl<B, R0, R1> Record<B> for (R0, R1)
where B: Backend, R0: Record<B>, R1: Record<B>,

fn into_item<S>(self) -> <(R0, R1) as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <(R0, R1) as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> (R0, R1)
where S: PrecisionSettings,

impl<B, R0, R1, R2> Record<B> for (R0, R1, R2)
where B: Backend, R0: Record<B>, R1: Record<B>, R2: Record<B>,

fn into_item<S>(self) -> <(R0, R1, R2) as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <(R0, R1, R2) as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> (R0, R1, R2)
where S: PrecisionSettings,

impl<B, R0, R1, R2, R3> Record<B> for (R0, R1, R2, R3)
where B: Backend, R0: Record<B>, R1: Record<B>, R2: Record<B>, R3: Record<B>,

fn into_item<S>(self) -> <(R0, R1, R2, R3) as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <(R0, R1, R2, R3) as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> (R0, R1, R2, R3)
where S: PrecisionSettings,

impl<B, R0, R1, R2, R3, R4> Record<B> for (R0, R1, R2, R3, R4)
where B: Backend, R0: Record<B>, R1: Record<B>, R2: Record<B>, R3: Record<B>, R4: Record<B>,

fn into_item<S>(self) -> <(R0, R1, R2, R3, R4) as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <(R0, R1, R2, R3, R4) as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> (R0, R1, R2, R3, R4)
where S: PrecisionSettings,

impl<B, R0, R1, R2, R3, R4, R5> Record<B> for (R0, R1, R2, R3, R4, R5)
where B: Backend, R0: Record<B>, R1: Record<B>, R2: Record<B>, R3: Record<B>, R4: Record<B>, R5: Record<B>,

fn into_item<S>(self) -> <(R0, R1, R2, R3, R4, R5) as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <(R0, R1, R2, R3, R4, R5) as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> (R0, R1, R2, R3, R4, R5)
where S: PrecisionSettings,

impl<B, R0, R1, R2, R3, R4, R5, R6> Record<B> for (R0, R1, R2, R3, R4, R5, R6)
where B: Backend, R0: Record<B>, R1: Record<B>, R2: Record<B>, R3: Record<B>, R4: Record<B>, R5: Record<B>, R6: Record<B>,

fn into_item<S>(self) -> <(R0, R1, R2, R3, R4, R5, R6) as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <(R0, R1, R2, R3, R4, R5, R6) as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> (R0, R1, R2, R3, R4, R5, R6)
where S: PrecisionSettings,

impl<B, R0, R1, R2, R3, R4, R5, R6, R7> Record<B> for (R0, R1, R2, R3, R4, R5, R6, R7)
where B: Backend, R0: Record<B>, R1: Record<B>, R2: Record<B>, R3: Record<B>, R4: Record<B>, R5: Record<B>, R6: Record<B>, R7: Record<B>,

fn into_item<S>( self, ) -> <(R0, R1, R2, R3, R4, R5, R6, R7) as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <(R0, R1, R2, R3, R4, R5, R6, R7) as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> (R0, R1, R2, R3, R4, R5, R6, R7)
where S: PrecisionSettings,

impl<B, R0, R1, R2, R3, R4, R5, R6, R7, R8> Record<B> for (R0, R1, R2, R3, R4, R5, R6, R7, R8)
where B: Backend, R0: Record<B>, R1: Record<B>, R2: Record<B>, R3: Record<B>, R4: Record<B>, R5: Record<B>, R6: Record<B>, R7: Record<B>, R8: Record<B>,

fn into_item<S>( self, ) -> <(R0, R1, R2, R3, R4, R5, R6, R7, R8) as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <(R0, R1, R2, R3, R4, R5, R6, R7, R8) as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> (R0, R1, R2, R3, R4, R5, R6, R7, R8)
where S: PrecisionSettings,

impl<B, R0, R1, R2, R3, R4, R5, R6, R7, R8, R9> Record<B> for (R0, R1, R2, R3, R4, R5, R6, R7, R8, R9)
where B: Backend, R0: Record<B>, R1: Record<B>, R2: Record<B>, R3: Record<B>, R4: Record<B>, R5: Record<B>, R6: Record<B>, R7: Record<B>, R8: Record<B>, R9: Record<B>,

fn into_item<S>( self, ) -> <(R0, R1, R2, R3, R4, R5, R6, R7, R8, R9) as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <(R0, R1, R2, R3, R4, R5, R6, R7, R8, R9) as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> (R0, R1, R2, R3, R4, R5, R6, R7, R8, R9)
where S: PrecisionSettings,

impl<T, B> Record<B> for Option<T>
where T: Record<B>, B: Backend,

fn into_item<S>(self) -> <Option<T> as Record<B>>::Item<S>
where S: PrecisionSettings,

fn from_item<S>( item: <Option<T> as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> Option<T>
where S: PrecisionSettings,

impl<T, B> Record<B> for Vec<T>
where T: Record<B>, B: Backend,

fn into_item<S>(self) -> <Vec<T> as Record<B>>::Item<S> ⓘ
where S: PrecisionSettings,

fn from_item<S>( item: <Vec<T> as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> Vec<T>
where S: PrecisionSettings,

impl<T, B> Record<B> for HashMap<ParamId, T>
where T: Record<B>, B: Backend,

fn into_item<S>(self) -> <HashMap<ParamId, T> as Record<B>>::Item<S>
where S: PrecisionSettings,