Trait Transform 

pub trait Transform<T>: Send + Sync {
    type Output;

    // Required method
    fn transform(&self, input: T) -> Result<Self::Output>;

    // Provided methods
    fn transform_batch(&self, inputs: Vec<T>) -> Result<Vec<Self::Output>> { ... }
    fn is_deterministic(&self) -> bool { ... }
}

Trait for data transformations

This is the core abstraction for all data transformations in the ToRSh ecosystem. Implementations should be stateless where possible and thread-safe.

Required Associated Types

type Output

Output type after transformation

Required Methods

fn transform(&self, input: T) -> Result<Self::Output>

Apply the transformation to a single input

Provided Methods

fn transform_batch(&self, inputs: Vec<T>) -> Result<Vec<Self::Output>>

Transform multiple items in batch

Default implementation applies transform individually, but implementations can override this for more efficient batch processing.

fn is_deterministic(&self) -> bool

Check if the transform is deterministic

A deterministic transform always produces the same output for the same input. Non-deterministic transforms include random augmentations.

Implementors

impl<From: TensorElement, To: TensorElement> Transform<Tensor<From>> for ToType<From, To>

type Output = Tensor<To>

impl<T> Transform<T> for Compose<T>

type Output = T

impl<T, O, F> Transform<T> for Lambda<F>

where F: Fn(T) -> Result<O> + Send + Sync,

type Output = O

impl<T, T1, T2> Transform<T> for Chain<T1, T2>

where T1: Transform<T>, T2: Transform<T1::Output>,

type Output = <T2 as Transform<<T1 as Transform<T>>::Output>>::Output

impl<T, U, P> Transform<T> for Conditional<U, P>

where U: Transform<T, Output = T>, P: Fn(&T) -> bool + Send + Sync,

type Output = T

impl<T: TensorElement> Transform<Tensor<T>> for Normalize<T>

type Output = Tensor<T>