Trait Record 

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

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

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

Required Associated Types

type Item<S: PrecisionSettings>: Serialize + DeserializeOwned + Clone

Type of the item that can be serialized and deserialized.

Required Methods

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

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

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

Convert the given item into a record.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

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

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>, <R5 as Record<B>>::Item<S>, <R6 as Record<B>>::Item<S>, <R7 as Record<B>>::Item<S>, <R8 as Record<B>>::Item<S>, <R9 as Record<B>>::Item<S>)

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

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

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

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>, <R5 as Record<B>>::Item<S>, <R6 as Record<B>>::Item<S>, <R7 as Record<B>>::Item<S>, <R8 as Record<B>>::Item<S>)

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

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

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

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>, <R5 as Record<B>>::Item<S>, <R6 as Record<B>>::Item<S>, <R7 as Record<B>>::Item<S>)

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

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

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

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>, <R5 as Record<B>>::Item<S>, <R6 as Record<B>>::Item<S>)

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

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

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

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>, <R5 as Record<B>>::Item<S>)

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

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

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: PrecisionSettings>(self) -> Self::Item<S>

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

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: PrecisionSettings>(self) -> Self::Item<S>

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

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: PrecisionSettings>(self) -> Self::Item<S>

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

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: PrecisionSettings>(self) -> Self::Item<S>

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

impl<B, R0> Record<B> for (R0,)

where B: Backend, R0: Record<B>,

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

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

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

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

type Item<S: PrecisionSettings> = String

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

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

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

type Item<S: PrecisionSettings> = bool

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

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

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

type Item<S: PrecisionSettings> = f32

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

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

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

type Item<S: PrecisionSettings> = f64

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

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

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

type Item<S: PrecisionSettings> = i8

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

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

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

type Item<S: PrecisionSettings> = i16

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

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

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

type Item<S: PrecisionSettings> = i32

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

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

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

type Item<S: PrecisionSettings> = i64

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

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

impl<B: Backend> Record<B> for isize

type Item<S: PrecisionSettings> = isize

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

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

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

type Item<S: PrecisionSettings> = u8

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

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

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

type Item<S: PrecisionSettings> = u16

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

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

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

type Item<S: PrecisionSettings> = u32

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

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

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

type Item<S: PrecisionSettings> = u64

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

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

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

type Item<S: PrecisionSettings> = usize

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

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

impl<B> Record<B> for ()

where B: Backend,

type Item<S: PrecisionSettings> = ()

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

fn from_item<S: PrecisionSettings>( _item: Self::Item<S>, _device: &B::Device, ) -> Self

impl<T, B> Record<B> for HashMap<ParamId, T>

where T: Record<B>, B: Backend,

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

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

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

impl<T, B> Record<B> for Option<T>

where T: Record<B>, B: Backend,

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

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

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

impl<T, B> Record<B> for Vec<T>

where T: Record<B>, B: Backend,

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

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

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

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

where T: Record<B>, B: Backend,

type Item<S: PrecisionSettings> = Array<N, <T as Record<B>>::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: PrecisionSettings>(self) -> Self::Item<S>

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

Implementors

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

where B: Backend,

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

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

where B: Backend,

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

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

where B: Backend,

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

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

type Item<S: PrecisionSettings> = BoolTensorSerde

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

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

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

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

impl<B: Backend> Record<B> for EmptyRecord

type Item<S: PrecisionSettings> = EmptyRecord

impl<B: Backend> Record<B> for ModuleDTypeRecord

type Item<P: PrecisionSettings> = ModuleDTypeRecord

impl<B: Backend> Record<B> for bf16

type Item<S: PrecisionSettings> = bf16

impl<B: Backend> Record<B> for f16

type Item<S: PrecisionSettings> = f16

impl<B: SparseOps> Record<B> for CsrTensorRecord<B>

where B::CsrData: Serialize + DeserializeOwned,

type Item<S: PrecisionSettings> = <B as SparseOps>::CsrData