Struct ha_ndarray::ArrayOp

pub struct ArrayOp<Op> { /* private fields */ }

An array operation

Implementations

impl<Op> ArrayOp<Op>

pub fn new(shape: Shape, op: Op) -> Self

Construct a new array operation.

Examples found in repository

examples/backprop.rs (line 12)

fn main() -> Result<(), Error> {
    let context = Context::default()?;
    let weights = RandomNormal::with_context(context.clone(), 2)?;
    let weights = ArrayOp::new(vec![2, 1], weights) - 0.5;
    let mut weights = ArrayBase::<Arc<RwLock<Buffer<f32>>>>::copy(&weights)?;

    let inputs = RandomUniform::with_context(context, vec![NUM_EXAMPLES, 2])?;
    let inputs = ArrayOp::new(vec![NUM_EXAMPLES, 2], inputs) * 2.;
    let inputs = ArrayBase::<Arc<Buffer<f32>>>::copy(&inputs)?;

    let inputs_bool = inputs.clone().lt_scalar(1.0)?;

    let inputs_left = inputs_bool
        .clone()
        .slice(vec![(0..NUM_EXAMPLES).into(), 0.into()])?;

    let inputs_right = inputs_bool.slice(vec![(0..NUM_EXAMPLES).into(), 1.into()])?;

    let labels = inputs_left
        .and(inputs_right)?
        .expand_dims(vec![1])?
        .cast()?;

    let labels = ArrayBase::<Buffer<f32>>::copy(&labels)?;

    let output = inputs.matmul(weights.clone())?;
    let error = labels.sub(output)?;
    let loss = error.clone().pow_scalar(2.)?;

    let d_loss = error * 2.;
    let weights_t = weights.clone().transpose(None)?;
    let gradient = d_loss.matmul(weights_t)?;
    let deltas = gradient.sum(vec![0], false)?.expand_dims(vec![1])?;
    let new_weights = weights.clone().add(deltas * LEARNING_RATE)?;

    let mut i = 0;
    loop {
        let loss = ArrayBase::<Buffer<f32>>::copy(&loss)?;

        if loss.clone().lt_scalar(1.0)?.all()? {
            return Ok(());
        }

        if i % 100 == 0 {
            println!(
                "loss: {} (max {})",
                loss.clone().sum_all()?,
                loss.clone().max_all()?
            );
        }

        assert!(!loss.clone().is_inf()?.any()?, "divergence at iteration {i}");
        assert!(!loss.is_nan()?.any()?, "unstable by iteration {i}");

        weights.write(&new_weights)?;

        i += 1;
    }
}

Trait Implementations

impl<T: CDatatype, Op: Op<Out = T>, O> Add<ArrayBase<O>> for ArrayOp<Op>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayBase<O>>>

The resulting type after applying the + operator.

fn add(self, rhs: ArrayBase<O>) -> Self::Output

Performs the + operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Add<ArrayOp<O>> for ArrayBase<Buf>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayOp<O>>>

The resulting type after applying the + operator.

fn add(self, rhs: ArrayOp<O>) -> Self::Output

Performs the + operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Add<ArrayOp<O>> for ArrayOp<Op>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayOp<O>>>

The resulting type after applying the + operator.

fn add(self, rhs: ArrayOp<O>) -> Self::Output

Performs the + operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Add<ArrayOp<O>> for ArraySlice<A>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArraySlice<A>, ArrayOp<O>>>

The resulting type after applying the + operator.

fn add(self, rhs: ArrayOp<O>) -> Self::Output

Performs the + operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Add<ArrayOp<O>> for ArrayView<A>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayView<A>, ArrayOp<O>>>

The resulting type after applying the + operator.

fn add(self, rhs: ArrayOp<O>) -> Self::Output

Performs the + operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Add<ArraySlice<O>> for ArrayOp<Op>where ArraySlice<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArraySlice<O>>>

The resulting type after applying the + operator.

fn add(self, rhs: ArraySlice<O>) -> Self::Output

Performs the + operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Add<ArrayView<O>> for ArrayOp<Op>where ArrayView<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayView<O>>>

The resulting type after applying the + operator.

fn add(self, rhs: ArrayView<O>) -> Self::Output

Performs the + operation.

impl<T: CDatatype, Op: Op<Out = T>> Add<T> for ArrayOp<Op>

type Output = ArrayOp<ArrayScalar<<Op as Op>::Out, ArrayOp<Op>>>

The resulting type after applying the + operator.

fn add(self, rhs: Op::Out) -> Self::Output

Performs the + operation.

impl<Op: Clone> Clone for ArrayOp<Op>

fn clone(&self) -> ArrayOp<Op>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Op: Op> Debug for ArrayOp<Op>

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

Formats the value using the given formatter.

impl<T: CDatatype, Op: Op<Out = T>, O> Div<ArrayBase<O>> for ArrayOp<Op>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayBase<O>>>

The resulting type after applying the / operator.

fn div(self, rhs: ArrayBase<O>) -> Self::Output

Performs the / operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Div<ArrayOp<O>> for ArrayBase<Buf>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayOp<O>>>

The resulting type after applying the / operator.

fn div(self, rhs: ArrayOp<O>) -> Self::Output

Performs the / operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Div<ArrayOp<O>> for ArrayOp<Op>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayOp<O>>>

The resulting type after applying the / operator.

fn div(self, rhs: ArrayOp<O>) -> Self::Output

Performs the / operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Div<ArrayOp<O>> for ArraySlice<A>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArraySlice<A>, ArrayOp<O>>>

The resulting type after applying the / operator.

fn div(self, rhs: ArrayOp<O>) -> Self::Output

Performs the / operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Div<ArrayOp<O>> for ArrayView<A>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayView<A>, ArrayOp<O>>>

The resulting type after applying the / operator.

fn div(self, rhs: ArrayOp<O>) -> Self::Output

Performs the / operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Div<ArraySlice<O>> for ArrayOp<Op>where ArraySlice<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArraySlice<O>>>

The resulting type after applying the / operator.

fn div(self, rhs: ArraySlice<O>) -> Self::Output

Performs the / operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Div<ArrayView<O>> for ArrayOp<Op>where ArrayView<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayView<O>>>

The resulting type after applying the / operator.

fn div(self, rhs: ArrayView<O>) -> Self::Output

Performs the / operation.

impl<T: CDatatype, Op: Op<Out = T>> Div<T> for ArrayOp<Op>

type Output = ArrayOp<ArrayScalar<<Op as Op>::Out, ArrayOp<Op>>>

The resulting type after applying the / operator.

fn div(self, rhs: Op::Out) -> Self::Output

Performs the / operation.

impl<Op: Op + 'static> From<ArrayOp<Op>> for Array<Op::Out>

fn from(op: ArrayOp<Op>) -> Self

Converts to this type from the input type.

impl<T: CDatatype, Op: Op<Out = T>, O> Mul<ArrayBase<O>> for ArrayOp<Op>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayBase<O>>>

The resulting type after applying the * operator.

fn mul(self, rhs: ArrayBase<O>) -> Self::Output

Performs the * operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Mul<ArrayOp<O>> for ArrayBase<Buf>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayOp<O>>>

The resulting type after applying the * operator.

fn mul(self, rhs: ArrayOp<O>) -> Self::Output

Performs the * operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Mul<ArrayOp<O>> for ArrayOp<Op>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayOp<O>>>

The resulting type after applying the * operator.

fn mul(self, rhs: ArrayOp<O>) -> Self::Output

Performs the * operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Mul<ArrayOp<O>> for ArraySlice<A>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArraySlice<A>, ArrayOp<O>>>

The resulting type after applying the * operator.

fn mul(self, rhs: ArrayOp<O>) -> Self::Output

Performs the * operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Mul<ArrayOp<O>> for ArrayView<A>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayView<A>, ArrayOp<O>>>

The resulting type after applying the * operator.

fn mul(self, rhs: ArrayOp<O>) -> Self::Output

Performs the * operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Mul<ArraySlice<O>> for ArrayOp<Op>where ArraySlice<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArraySlice<O>>>

The resulting type after applying the * operator.

fn mul(self, rhs: ArraySlice<O>) -> Self::Output

Performs the * operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Mul<ArrayView<O>> for ArrayOp<Op>where ArrayView<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayView<O>>>

The resulting type after applying the * operator.

fn mul(self, rhs: ArrayView<O>) -> Self::Output

Performs the * operation.

impl<T: CDatatype, Op: Op<Out = T>> Mul<T> for ArrayOp<Op>

type Output = ArrayOp<ArrayScalar<<Op as Op>::Out, ArrayOp<Op>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Op::Out) -> Self::Output

Performs the * operation.

impl<Op: Op> NDArray for ArrayOp<Op>

type DType = <Op as Op>::Out

The data type of the elements in this array

fn context(&self) -> &Context

Borrow the execution Context of this array.

fn shape(&self) -> &[usize]

Borrow the shape of this array.

fn ndim(&self) -> usize

Return the number of dimensions in this array.

fn size(&self) -> usize

Return the number of elements in this array.

impl<Op: Op> NDArrayRead for ArrayOp<Op>

fn read(&self, queue: &Queue) -> Result<BufferConverter<'_, Op::Out>, Error>

Read the value of this NDArray.

fn read_value(&self, coord: &[usize]) -> Result<Self::DType, Error>

Read the value at one coord in this NDArray.

fn to_host( &self, queue: &Queue ) -> Result<SliceConverter<'_, Self::DType>, Error>

Read the value of this NDArray as a SliceConverter in main memory

impl<Op: Op> NDArrayTransform for ArrayOp<Op>

type Broadcast = ArrayView<ArrayOp<Op>>

The type returned by broadcast

type Expand = ArrayOp<Op>

The type returned by expand_dims

type Reshape = ArrayOp<Op>

The type returned by reshape

type Slice = ArraySlice<ArrayOp<Op>>

The type returned by slice

type Transpose = ArrayView<ArrayOp<Op>>

The type returned by transpose

fn broadcast(self, shape: Shape) -> Result<Self::Broadcast, Error>

Broadcast this array into the given shape.

fn expand_dims(self, axes: Vec<usize>) -> Result<Self::Expand, Error>

Expand the given axes of this array.

fn reshape(self, shape: Shape) -> Result<Self::Reshape, Error>

Reshape this array into the given shape.

fn slice(self, bounds: Vec<AxisBound>) -> Result<Self::Slice, Error>

Construct a slice of this array.

fn transpose(self, axes: Option<Vec<usize>>) -> Result<Self::Transpose, Error>

Transpose this array according to the given permutation. If no permutation is given, the array axes will be reversed.

impl<Op: Op> Neg for ArrayOp<Op>

type Output = ArrayOp<ArrayUnary<<Op as Op>::Out, <<Op as Op>::Out as CDatatype>::Neg, ArrayOp<Op>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Op: Op> Not for ArrayOp<Op>

type Output = ArrayOp<ArrayUnary<<Op as Op>::Out, u8, ArrayOp<Op>>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Rem<ArrayBase<O>> for ArrayOp<Op>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayBase<O>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArrayBase<O>) -> Self::Output

Performs the % operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Rem<ArrayOp<O>> for ArrayBase<Buf>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayOp<O>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArrayOp<O>) -> Self::Output

Performs the % operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Rem<ArrayOp<O>> for ArrayOp<Op>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayOp<O>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArrayOp<O>) -> Self::Output

Performs the % operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Rem<ArrayOp<O>> for ArraySlice<A>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArraySlice<A>, ArrayOp<O>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArrayOp<O>) -> Self::Output

Performs the % operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Rem<ArrayOp<O>> for ArrayView<A>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayView<A>, ArrayOp<O>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArrayOp<O>) -> Self::Output

Performs the % operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Rem<ArraySlice<O>> for ArrayOp<Op>where ArraySlice<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArraySlice<O>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArraySlice<O>) -> Self::Output

Performs the % operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Rem<ArrayView<O>> for ArrayOp<Op>where ArrayView<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayView<O>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArrayView<O>) -> Self::Output

Performs the % operation.

impl<T: CDatatype, Op: Op<Out = T>> Rem<T> for ArrayOp<Op>

type Output = ArrayOp<ArrayScalar<<Op as Op>::Out, ArrayOp<Op>>>

The resulting type after applying the % operator.

fn rem(self, rhs: Op::Out) -> Self::Output

Performs the % operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Sub<ArrayBase<O>> for ArrayOp<Op>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayBase<O>>>

The resulting type after applying the - operator.

fn sub(self, rhs: ArrayBase<O>) -> Self::Output

Performs the - operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Sub<ArrayOp<O>> for ArrayBase<Buf>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayOp<O>>>

The resulting type after applying the - operator.

fn sub(self, rhs: ArrayOp<O>) -> Self::Output

Performs the - operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Sub<ArrayOp<O>> for ArrayOp<Op>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayOp<O>>>

The resulting type after applying the - operator.

fn sub(self, rhs: ArrayOp<O>) -> Self::Output

Performs the - operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Sub<ArrayOp<O>> for ArraySlice<A>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArraySlice<A>, ArrayOp<O>>>

The resulting type after applying the - operator.

fn sub(self, rhs: ArrayOp<O>) -> Self::Output

Performs the - operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Sub<ArrayOp<O>> for ArrayView<A>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayView<A>, ArrayOp<O>>>

The resulting type after applying the - operator.

fn sub(self, rhs: ArrayOp<O>) -> Self::Output

Performs the - operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Sub<ArraySlice<O>> for ArrayOp<Op>where ArraySlice<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArraySlice<O>>>

The resulting type after applying the - operator.

fn sub(self, rhs: ArraySlice<O>) -> Self::Output

Performs the - operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Sub<ArrayView<O>> for ArrayOp<Op>where ArrayView<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayView<O>>>

The resulting type after applying the - operator.

fn sub(self, rhs: ArrayView<O>) -> Self::Output

Performs the - operation.

impl<T: CDatatype, Op: Op<Out = T>> Sub<T> for ArrayOp<Op>

type Output = ArrayOp<ArrayScalar<<Op as Op>::Out, ArrayOp<Op>>>

The resulting type after applying the - operator.

fn sub(self, rhs: Op::Out) -> Self::Output

Performs the - operation.