From f0a6613718f724305cc99ee1186bfe33a55652ae Mon Sep 17 00:00:00 2001 From: "Thomas S. Bauer" Date: Wed, 15 Nov 2023 11:45:45 +0100 Subject: [PATCH 1/3] Add nodegen script --- nodegen/node/sequence_length.py | 173 ++++++++++++++++++++++++++++++++ 1 file changed, 173 insertions(+) create mode 100644 nodegen/node/sequence_length.py diff --git a/nodegen/node/sequence_length.py b/nodegen/node/sequence_length.py new file mode 100644 index 000000000..87f0dcd01 --- /dev/null +++ b/nodegen/node/sequence_length.py @@ -0,0 +1,173 @@ +import numpy as np +from nodegen.node import RunAll +from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl + + +scalar = lambda x: Tensor(Dtype.U32, (), np.array([x]).astype(np.uint32).flatten()) + + +class Sequence_length(RunAll): + @staticmethod + def sequence_length_u32(): + def default(): + sequence = [] + tensor_cnt = np.random.randint(1, 10) + shape = np.random.randint(1, 4, 2) + + for _ in range(tensor_cnt): + values = np.random.randint(0, 6, shape).astype(np.uint32) + tensor = Tensor(Dtype.U32, values.shape, values.flatten()) + + sequence.append(tensor) + + name = "sequence_length_u32" + make_test([sequence], scalar(len(sequence)), "input_0.sequence_length()", name) + + def broadcast(): + sequence = [] + tensor_cnt = np.random.randint(1, 10) + + for _ in range(tensor_cnt): + shape = np.random.randint(1, 4, 2) + values = np.random.randint(0, 6, shape).astype(np.uint32) + tensor = Tensor(Dtype.U32, values.shape, values.flatten()) + + sequence.append(tensor) + + name = "sequence_length_u32_broadcast" + make_test([sequence], scalar(len(sequence)), "input_0.sequence_length()", name) + + default() + broadcast() + + @staticmethod + def sequence_length_i32(): + def default(): + sequence = [] + tensor_cnt = np.random.randint(1, 10) + shape = np.random.randint(1, 4, 2) + + for _ in range(tensor_cnt): + values = np.random.randint(-6, 6, shape).astype(np.int32) + tensor = Tensor(Dtype.I32, values.shape, values.flatten()) + + sequence.append(tensor) + + name = "sequence_length_i32" + make_test([sequence], scalar(len(sequence)), "input_0.sequence_length()", name) + + def broadcast(): + sequence = [] + tensor_cnt = np.random.randint(1, 10) + + for _ in range(tensor_cnt): + shape = np.random.randint(1, 4, 2) + values = np.random.randint(-6, 6, shape).astype(np.int32) + tensor = Tensor(Dtype.I32, values.shape, values.flatten()) + + sequence.append(tensor) + + name = "sequence_length_i32_broadcast" + make_test([sequence], scalar(len(sequence)), "input_0.sequence_length()", name) + + default() + broadcast() + + @staticmethod + def sequence_length_i8(): + def default(): + sequence = [] + tensor_cnt = np.random.randint(1, 10) + shape = np.random.randint(1, 4, 2) + + for _ in range(tensor_cnt): + values = np.random.randint(-6, 6, shape).astype(np.int8) + tensor = Tensor(Dtype.I8, values.shape, values.flatten()) + + sequence.append(tensor) + + name = "sequence_length_i8" + make_test([sequence], scalar(len(sequence)), "input_0.sequence_length()", name) + + def broadcast(): + sequence = [] + tensor_cnt = np.random.randint(1, 10) + + for _ in range(tensor_cnt): + shape = np.random.randint(1, 4, 2) + values = np.random.randint(-6, 6, shape).astype(np.int8) + tensor = Tensor(Dtype.I8, values.shape, values.flatten()) + + sequence.append(tensor) + + name = "sequence_length_i8_broadcast" + make_test([sequence], scalar(len(sequence)), "input_0.sequence_length()", name) + + default() + broadcast() + + @staticmethod + def sequence_length_fp8x23(): + def default(): + sequence = [] + tensor_cnt = np.random.randint(1, 10) + shape = np.random.randint(1, 4, 2) + + for _ in range(tensor_cnt): + values = np.random.randint(-6, 6, shape).astype(np.float64) + tensor = Tensor(Dtype.FP8x23, values.shape, to_fp(values.flatten(), FixedImpl.FP8x23)) + + sequence.append(tensor) + + name = "sequence_length_fp8x23" + make_test([sequence], scalar(len(sequence)), "input_0.sequence_length()", name) + + def broadcast(): + sequence = [] + tensor_cnt = np.random.randint(1, 10) + + for _ in range(tensor_cnt): + shape = np.random.randint(1, 4, 2) + values = np.random.randint(-6, 6, shape).astype(np.float64) + tensor = Tensor(Dtype.FP8x23, values.shape, to_fp(values.flatten(), FixedImpl.FP8x23)) + + sequence.append(tensor) + + name = "sequence_length_fp8x23_broadcast" + make_test([sequence], scalar(len(sequence)), "input_0.sequence_length()", name) + + default() + broadcast() + + @staticmethod + def sequence_length_fp16x16(): + def default(): + sequence = [] + tensor_cnt = np.random.randint(1, 10) + shape = np.random.randint(1, 4, 2) + + for _ in range(tensor_cnt): + values = np.random.randint(-6, 6, shape).astype(np.float64) + tensor = Tensor(Dtype.FP16x16, values.shape, to_fp(values.flatten(), FixedImpl.FP16x16)) + + sequence.append(tensor) + + name = "sequence_length_fp16x16" + make_test([sequence], scalar(len(sequence)), "input_0.sequence_length()", name) + + def broadcast(): + sequence = [] + tensor_cnt = np.random.randint(1, 10) + + for _ in range(tensor_cnt): + shape = np.random.randint(1, 4, 2) + values = np.random.randint(-6, 6, shape).astype(np.float64) + tensor = Tensor(Dtype.FP16x16, values.shape, to_fp(values.flatten(), FixedImpl.FP16x16)) + + sequence.append(tensor) + + name = "sequence_length_fp16x16_broadcast" + make_test([sequence], scalar(len(sequence)), "input_0.sequence_length()", name) + + default() + broadcast() From cc5abb93c7cbae5239d91fe5705cf1902d472fce Mon Sep 17 00:00:00 2001 From: "Thomas S. Bauer" Date: Wed, 15 Nov 2023 13:27:03 +0100 Subject: [PATCH 2/3] Add tests and implementation --- src/operators/tensor/core.cairo | 3 + .../tensor/implementations/tensor_bool.cairo | 4 + .../implementations/tensor_fp16x16.cairo | 4 + .../implementations/tensor_fp16x16wide.cairo | 4 + .../implementations/tensor_fp32x32.cairo | 4 + .../implementations/tensor_fp64x64.cairo | 4 + .../implementations/tensor_fp8x23.cairo | 4 + .../implementations/tensor_fp8x23wide.cairo | 4 + .../tensor/implementations/tensor_i32.cairo | 4 + .../tensor/implementations/tensor_i8.cairo | 4 + .../tensor/implementations/tensor_u32.cairo | 4 + src/operators/tensor/math.cairo | 1 + .../tensor/math/sequence_length.cairo | 15 +++ tests/nodes.cairo | 10 ++ tests/nodes/sequence_length_fp16x16.cairo | 22 ++++ .../sequence_length_fp16x16/input_0.cairo | 109 ++++++++++++++++++ .../sequence_length_fp16x16/output_0.cairo | 11 ++ .../sequence_length_fp16x16_broadcast.cairo | 22 ++++ .../input_0.cairo | 88 ++++++++++++++ .../output_0.cairo | 11 ++ tests/nodes/sequence_length_fp8x23.cairo | 22 ++++ .../sequence_length_fp8x23/input_0.cairo | 70 +++++++++++ .../sequence_length_fp8x23/output_0.cairo | 11 ++ .../sequence_length_fp8x23_broadcast.cairo | 22 ++++ .../input_0.cairo | 20 ++++ .../output_0.cairo | 11 ++ tests/nodes/sequence_length_i32.cairo | 22 ++++ tests/nodes/sequence_length_i32/input_0.cairo | 30 +++++ .../nodes/sequence_length_i32/output_0.cairo | 11 ++ .../nodes/sequence_length_i32_broadcast.cairo | 22 ++++ .../input_0.cairo | 56 +++++++++ .../output_0.cairo | 11 ++ tests/nodes/sequence_length_i8.cairo | 22 ++++ tests/nodes/sequence_length_i8/input_0.cairo | 52 +++++++++ tests/nodes/sequence_length_i8/output_0.cairo | 11 ++ .../nodes/sequence_length_i8_broadcast.cairo | 22 ++++ .../input_0.cairo | 62 ++++++++++ .../output_0.cairo | 11 ++ tests/nodes/sequence_length_u32.cairo | 20 ++++ tests/nodes/sequence_length_u32/input_0.cairo | 26 +++++ .../nodes/sequence_length_u32/output_0.cairo | 11 ++ .../nodes/sequence_length_u32_broadcast.cairo | 20 ++++ .../input_0.cairo | 19 +++ .../output_0.cairo | 11 ++ 44 files changed, 927 insertions(+) create mode 100644 src/operators/tensor/math/sequence_length.cairo create mode 100644 tests/nodes/sequence_length_fp16x16.cairo create mode 100644 tests/nodes/sequence_length_fp16x16/input_0.cairo create mode 100644 tests/nodes/sequence_length_fp16x16/output_0.cairo create mode 100644 tests/nodes/sequence_length_fp16x16_broadcast.cairo create mode 100644 tests/nodes/sequence_length_fp16x16_broadcast/input_0.cairo create mode 100644 tests/nodes/sequence_length_fp16x16_broadcast/output_0.cairo create mode 100644 tests/nodes/sequence_length_fp8x23.cairo create mode 100644 tests/nodes/sequence_length_fp8x23/input_0.cairo create mode 100644 tests/nodes/sequence_length_fp8x23/output_0.cairo create mode 100644 tests/nodes/sequence_length_fp8x23_broadcast.cairo create mode 100644 tests/nodes/sequence_length_fp8x23_broadcast/input_0.cairo create mode 100644 tests/nodes/sequence_length_fp8x23_broadcast/output_0.cairo create mode 100644 tests/nodes/sequence_length_i32.cairo create mode 100644 tests/nodes/sequence_length_i32/input_0.cairo create mode 100644 tests/nodes/sequence_length_i32/output_0.cairo create mode 100644 tests/nodes/sequence_length_i32_broadcast.cairo create mode 100644 tests/nodes/sequence_length_i32_broadcast/input_0.cairo create mode 100644 tests/nodes/sequence_length_i32_broadcast/output_0.cairo create mode 100644 tests/nodes/sequence_length_i8.cairo create mode 100644 tests/nodes/sequence_length_i8/input_0.cairo create mode 100644 tests/nodes/sequence_length_i8/output_0.cairo create mode 100644 tests/nodes/sequence_length_i8_broadcast.cairo create mode 100644 tests/nodes/sequence_length_i8_broadcast/input_0.cairo create mode 100644 tests/nodes/sequence_length_i8_broadcast/output_0.cairo create mode 100644 tests/nodes/sequence_length_u32.cairo create mode 100644 tests/nodes/sequence_length_u32/input_0.cairo create mode 100644 tests/nodes/sequence_length_u32/output_0.cairo create mode 100644 tests/nodes/sequence_length_u32_broadcast.cairo create mode 100644 tests/nodes/sequence_length_u32_broadcast/input_0.cairo create mode 100644 tests/nodes/sequence_length_u32_broadcast/output_0.cairo diff --git a/src/operators/tensor/core.cairo b/src/operators/tensor/core.cairo index 9ac16691e..872117142 100644 --- a/src/operators/tensor/core.cairo +++ b/src/operators/tensor/core.cairo @@ -94,6 +94,7 @@ impl TensorSerde, impl TDrop: Drop> of Serde { /// # tensor.new /// @@ -3584,6 +3585,8 @@ trait TensorTrait { /// ``` /// fn constant_of_shape(shape: Span, value: T) -> Tensor; + /// TODO + fn sequence_length(self: Array>) -> Tensor; } /// Cf: TensorTrait::new docstring diff --git a/src/operators/tensor/implementations/tensor_bool.cairo b/src/operators/tensor/implementations/tensor_bool.cairo index 29bf1c77b..118fdf4fb 100644 --- a/src/operators/tensor/implementations/tensor_bool.cairo +++ b/src/operators/tensor/implementations/tensor_bool.cairo @@ -312,6 +312,10 @@ impl BoolTensor of TensorTrait { fn constant_of_shape(shape: Span, value: bool) -> Tensor { constant_of_shape(shape, value) } + + fn sequence_length(self: Array>) -> Tensor { + math::sequence_length::sequence_length(self) + } } /// Implements partial equal for two `Tensor` using the `PartialEq` trait. diff --git a/src/operators/tensor/implementations/tensor_fp16x16.cairo b/src/operators/tensor/implementations/tensor_fp16x16.cairo index 8b27883fa..07f736f90 100644 --- a/src/operators/tensor/implementations/tensor_fp16x16.cairo +++ b/src/operators/tensor/implementations/tensor_fp16x16.cairo @@ -340,6 +340,10 @@ impl FP16x16Tensor of TensorTrait { ) -> Tensor { math::scatter::scatter(self, updates, indices, axis, reduction) } + + fn sequence_length(self: Array>) -> Tensor { + math::sequence_length::sequence_length(self) + } } /// Implements addition for `Tensor` using the `Add` trait. diff --git a/src/operators/tensor/implementations/tensor_fp16x16wide.cairo b/src/operators/tensor/implementations/tensor_fp16x16wide.cairo index 68f2482e7..6877bf431 100644 --- a/src/operators/tensor/implementations/tensor_fp16x16wide.cairo +++ b/src/operators/tensor/implementations/tensor_fp16x16wide.cairo @@ -328,6 +328,10 @@ impl FP16x16WTensor of TensorTrait { fn reduce_l2(self: @Tensor, axis: usize, keepdims: bool) -> Tensor { math::reduce_l2::reduce_l2(self, axis, keepdims) } + + fn sequence_length(self: Array>) -> Tensor { + math::sequence_length::sequence_length(self) + } } /// Implements addition for `Tensor` using the `Add` trait. diff --git a/src/operators/tensor/implementations/tensor_fp32x32.cairo b/src/operators/tensor/implementations/tensor_fp32x32.cairo index f764b1920..f836082f2 100644 --- a/src/operators/tensor/implementations/tensor_fp32x32.cairo +++ b/src/operators/tensor/implementations/tensor_fp32x32.cairo @@ -341,6 +341,10 @@ impl FP32x32Tensor of TensorTrait { fn reduce_l2(self: @Tensor, axis: usize, keepdims: bool) -> Tensor { math::reduce_l2::reduce_l2(self, axis, keepdims) } + + fn sequence_length(self: Array>) -> Tensor { + math::sequence_length::sequence_length(self) + } } /// Implements addition for `Tensor` using the `Add` trait. diff --git a/src/operators/tensor/implementations/tensor_fp64x64.cairo b/src/operators/tensor/implementations/tensor_fp64x64.cairo index 6cded29b3..7f0c2a0c9 100644 --- a/src/operators/tensor/implementations/tensor_fp64x64.cairo +++ b/src/operators/tensor/implementations/tensor_fp64x64.cairo @@ -341,6 +341,10 @@ impl FP64x64Tensor of TensorTrait { ) -> Tensor { math::scatter::scatter(self, updates, indices, axis, reduction) } + + fn sequence_length(self: Array>) -> Tensor { + math::sequence_length::sequence_length(self) + } } /// Implements addition for `Tensor` using the `Add` trait. diff --git a/src/operators/tensor/implementations/tensor_fp8x23.cairo b/src/operators/tensor/implementations/tensor_fp8x23.cairo index fdcdac1eb..2629e9076 100644 --- a/src/operators/tensor/implementations/tensor_fp8x23.cairo +++ b/src/operators/tensor/implementations/tensor_fp8x23.cairo @@ -340,6 +340,10 @@ impl FP8x23Tensor of TensorTrait { fn reduce_l2(self: @Tensor, axis: usize, keepdims: bool) -> Tensor { math::reduce_l2::reduce_l2(self, axis, keepdims) } + + fn sequence_length(self: Array>) -> Tensor { + math::sequence_length::sequence_length(self) + } } /// Implements addition for `Tensor` using the `Add` trait. diff --git a/src/operators/tensor/implementations/tensor_fp8x23wide.cairo b/src/operators/tensor/implementations/tensor_fp8x23wide.cairo index 510731702..202db085f 100644 --- a/src/operators/tensor/implementations/tensor_fp8x23wide.cairo +++ b/src/operators/tensor/implementations/tensor_fp8x23wide.cairo @@ -318,6 +318,10 @@ impl FP8x23WTensor of TensorTrait { ) -> Tensor { math::scatter::scatter(self, updates, indices, axis, reduction) } + + fn sequence_length(self: Array>) -> Tensor { + math::sequence_length::sequence_length(self) + } } /// Implements addition for `Tensor` using the `Add` trait. diff --git a/src/operators/tensor/implementations/tensor_i32.cairo b/src/operators/tensor/implementations/tensor_i32.cairo index 8017ab300..af8994a03 100644 --- a/src/operators/tensor/implementations/tensor_i32.cairo +++ b/src/operators/tensor/implementations/tensor_i32.cairo @@ -340,6 +340,10 @@ impl I32Tensor of TensorTrait { fn reduce_l2(self: @Tensor, axis: usize, keepdims: bool) -> Tensor { panic(array!['not supported!']) } + + fn sequence_length(self: Array>) -> Tensor { + math::sequence_length::sequence_length(self) + } } /// Implements addition for `Tensor` using the `Add` trait. diff --git a/src/operators/tensor/implementations/tensor_i8.cairo b/src/operators/tensor/implementations/tensor_i8.cairo index 4f2731b80..5fcb5f635 100644 --- a/src/operators/tensor/implementations/tensor_i8.cairo +++ b/src/operators/tensor/implementations/tensor_i8.cairo @@ -339,6 +339,10 @@ impl I8Tensor of TensorTrait { fn reduce_l2(self: @Tensor, axis: usize, keepdims: bool) -> Tensor { panic(array!['not supported!']) } + + fn sequence_length(self: Array>) -> Tensor { + math::sequence_length::sequence_length(self) + } } /// Implements addition for `Tensor` using the `Add` trait. diff --git a/src/operators/tensor/implementations/tensor_u32.cairo b/src/operators/tensor/implementations/tensor_u32.cairo index 2f3c3a2ef..ed28b5872 100644 --- a/src/operators/tensor/implementations/tensor_u32.cairo +++ b/src/operators/tensor/implementations/tensor_u32.cairo @@ -310,6 +310,10 @@ impl U32Tensor of TensorTrait { fn reduce_l2(self: @Tensor, axis: usize, keepdims: bool) -> Tensor { panic(array!['not supported!']) } + + fn sequence_length(self: Array>) -> Tensor { + math::sequence_length::sequence_length(self) + } } /// Implements addition for `Tensor` using the `Add` trait. diff --git a/src/operators/tensor/math.cairo b/src/operators/tensor/math.cairo index 881642e20..856a73f1d 100644 --- a/src/operators/tensor/math.cairo +++ b/src/operators/tensor/math.cairo @@ -43,3 +43,4 @@ mod reduce_l2; mod reduce_l1; mod reduce_sum_square; mod bitwise_and; +mod sequence_length; diff --git a/src/operators/tensor/math/sequence_length.cairo b/src/operators/tensor/math/sequence_length.cairo new file mode 100644 index 000000000..36aacae5a --- /dev/null +++ b/src/operators/tensor/math/sequence_length.cairo @@ -0,0 +1,15 @@ +use array::{ArrayTrait, SpanTrait}; + +use orion::operators::tensor::{TensorTrait, Tensor}; + + +fn sequence_length>(self: Array>) -> Tensor { + let mut shape = ArrayTrait::::new(); + let mut result = ArrayTrait::new(); + result.append(self.len()); + + Tensor:: { + shape: shape.span(), + data: result.span(), + } +} diff --git a/tests/nodes.cairo b/tests/nodes.cairo index 23f5c9731..69d3bfcbf 100644 --- a/tests/nodes.cairo +++ b/tests/nodes.cairo @@ -654,3 +654,13 @@ mod reduce_l1_i8_export_negative_axes_keepdims; mod reduce_l1_u32_export_do_not_keepdims; mod reduce_l1_u32_export_keepdims; mod reduce_l1_u32_export_negative_axes_keepdims; +mod sequence_length_fp16x16; +mod sequence_length_fp16x16_broadcast; +mod sequence_length_fp8x23; +mod sequence_length_fp8x23_broadcast; +mod sequence_length_i32; +mod sequence_length_i32_broadcast; +mod sequence_length_i8; +mod sequence_length_i8_broadcast; +mod sequence_length_u32; +mod sequence_length_u32_broadcast; diff --git a/tests/nodes/sequence_length_fp16x16.cairo b/tests/nodes/sequence_length_fp16x16.cairo new file mode 100644 index 000000000..44d9cf8b7 --- /dev/null +++ b/tests/nodes/sequence_length_fp16x16.cairo @@ -0,0 +1,22 @@ +mod input_0; +mod output_0; + + +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32TensorPartialEq; +use orion::utils::{assert_eq, assert_seq_eq}; +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::FP16x16Tensor; +use orion::operators::tensor::U32Tensor; +use orion::operators::tensor::FP16x16TensorPartialEq; + +#[test] +#[available_gas(2000000000)] +fn test_sequence_length_fp16x16() { + let input_0 = input_0::input_0(); + let z = output_0::output_0(); + + let y = input_0.sequence_length(); + + assert_eq(y, z); +} diff --git a/tests/nodes/sequence_length_fp16x16/input_0.cairo b/tests/nodes/sequence_length_fp16x16/input_0.cairo new file mode 100644 index 000000000..1943f2e3a --- /dev/null +++ b/tests/nodes/sequence_length_fp16x16/input_0.cairo @@ -0,0 +1,109 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::FP16x16Tensor; +use orion::numbers::{FixedTrait, FP16x16}; + +fn input_0() -> Array> { + let mut sequence = ArrayTrait::new(); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 262144, sign: true }); + data.append(FP16x16 { mag: 262144, sign: false }); + data.append(FP16x16 { mag: 262144, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 327680, sign: true }); + data.append(FP16x16 { mag: 327680, sign: false }); + data.append(FP16x16 { mag: 262144, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 0, sign: false }); + data.append(FP16x16 { mag: 327680, sign: true }); + data.append(FP16x16 { mag: 131072, sign: false }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 393216, sign: true }); + data.append(FP16x16 { mag: 65536, sign: false }); + data.append(FP16x16 { mag: 196608, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 131072, sign: true }); + data.append(FP16x16 { mag: 262144, sign: false }); + data.append(FP16x16 { mag: 65536, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 327680, sign: false }); + data.append(FP16x16 { mag: 65536, sign: true }); + data.append(FP16x16 { mag: 0, sign: false }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 196608, sign: true }); + data.append(FP16x16 { mag: 196608, sign: true }); + data.append(FP16x16 { mag: 262144, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 131072, sign: true }); + data.append(FP16x16 { mag: 131072, sign: true }); + data.append(FP16x16 { mag: 196608, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 65536, sign: true }); + data.append(FP16x16 { mag: 327680, sign: false }); + data.append(FP16x16 { mag: 196608, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + sequence +} diff --git a/tests/nodes/sequence_length_fp16x16/output_0.cairo b/tests/nodes/sequence_length_fp16x16/output_0.cairo new file mode 100644 index 000000000..cc6040e61 --- /dev/null +++ b/tests/nodes/sequence_length_fp16x16/output_0.cairo @@ -0,0 +1,11 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32Tensor; + +fn output_0() -> Tensor { + let mut shape = ArrayTrait::::new(); + + let mut data = ArrayTrait::new(); + data.append(9); + TensorTrait::new(shape.span(), data.span()) +} diff --git a/tests/nodes/sequence_length_fp16x16_broadcast.cairo b/tests/nodes/sequence_length_fp16x16_broadcast.cairo new file mode 100644 index 000000000..9c3996555 --- /dev/null +++ b/tests/nodes/sequence_length_fp16x16_broadcast.cairo @@ -0,0 +1,22 @@ +mod input_0; +mod output_0; + + +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32TensorPartialEq; +use orion::utils::{assert_eq, assert_seq_eq}; +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::FP16x16Tensor; +use orion::operators::tensor::U32Tensor; +use orion::operators::tensor::FP16x16TensorPartialEq; + +#[test] +#[available_gas(2000000000)] +fn test_sequence_length_fp16x16_broadcast() { + let input_0 = input_0::input_0(); + let z = output_0::output_0(); + + let y = input_0.sequence_length(); + + assert_eq(y, z); +} diff --git a/tests/nodes/sequence_length_fp16x16_broadcast/input_0.cairo b/tests/nodes/sequence_length_fp16x16_broadcast/input_0.cairo new file mode 100644 index 000000000..c15af2315 --- /dev/null +++ b/tests/nodes/sequence_length_fp16x16_broadcast/input_0.cairo @@ -0,0 +1,88 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::FP16x16Tensor; +use orion::numbers::{FixedTrait, FP16x16}; + +fn input_0() -> Array> { + let mut sequence = ArrayTrait::new(); + + let mut shape = ArrayTrait::::new(); + shape.append(2); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 131072, sign: true }); + data.append(FP16x16 { mag: 327680, sign: false }); + data.append(FP16x16 { mag: 327680, sign: true }); + data.append(FP16x16 { mag: 0, sign: false }); + data.append(FP16x16 { mag: 393216, sign: true }); + data.append(FP16x16 { mag: 262144, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(3); + shape.append(2); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 0, sign: false }); + data.append(FP16x16 { mag: 262144, sign: false }); + data.append(FP16x16 { mag: 0, sign: false }); + data.append(FP16x16 { mag: 327680, sign: false }); + data.append(FP16x16 { mag: 196608, sign: false }); + data.append(FP16x16 { mag: 262144, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(3); + shape.append(1); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 0, sign: false }); + data.append(FP16x16 { mag: 393216, sign: true }); + data.append(FP16x16 { mag: 327680, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(3); + shape.append(2); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 131072, sign: false }); + data.append(FP16x16 { mag: 131072, sign: true }); + data.append(FP16x16 { mag: 131072, sign: false }); + data.append(FP16x16 { mag: 196608, sign: false }); + data.append(FP16x16 { mag: 131072, sign: true }); + data.append(FP16x16 { mag: 131072, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(3); + shape.append(2); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 262144, sign: false }); + data.append(FP16x16 { mag: 327680, sign: false }); + data.append(FP16x16 { mag: 196608, sign: false }); + data.append(FP16x16 { mag: 131072, sign: true }); + data.append(FP16x16 { mag: 131072, sign: true }); + data.append(FP16x16 { mag: 262144, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(3); + shape.append(1); + + let mut data = ArrayTrait::new(); + data.append(FP16x16 { mag: 327680, sign: false }); + data.append(FP16x16 { mag: 196608, sign: true }); + data.append(FP16x16 { mag: 262144, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + sequence +} diff --git a/tests/nodes/sequence_length_fp16x16_broadcast/output_0.cairo b/tests/nodes/sequence_length_fp16x16_broadcast/output_0.cairo new file mode 100644 index 000000000..df7dfed8b --- /dev/null +++ b/tests/nodes/sequence_length_fp16x16_broadcast/output_0.cairo @@ -0,0 +1,11 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32Tensor; + +fn output_0() -> Tensor { + let mut shape = ArrayTrait::::new(); + + let mut data = ArrayTrait::new(); + data.append(6); + TensorTrait::new(shape.span(), data.span()) +} diff --git a/tests/nodes/sequence_length_fp8x23.cairo b/tests/nodes/sequence_length_fp8x23.cairo new file mode 100644 index 000000000..232dda071 --- /dev/null +++ b/tests/nodes/sequence_length_fp8x23.cairo @@ -0,0 +1,22 @@ +mod input_0; +mod output_0; + + +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::FP8x23TensorPartialEq; +use orion::operators::tensor::FP8x23Tensor; +use orion::operators::tensor::U32TensorPartialEq; +use orion::utils::{assert_eq, assert_seq_eq}; +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::U32Tensor; + +#[test] +#[available_gas(2000000000)] +fn test_sequence_length_fp8x23() { + let input_0 = input_0::input_0(); + let z = output_0::output_0(); + + let y = input_0.sequence_length(); + + assert_eq(y, z); +} diff --git a/tests/nodes/sequence_length_fp8x23/input_0.cairo b/tests/nodes/sequence_length_fp8x23/input_0.cairo new file mode 100644 index 000000000..5a57eb8e7 --- /dev/null +++ b/tests/nodes/sequence_length_fp8x23/input_0.cairo @@ -0,0 +1,70 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::FP8x23Tensor; +use orion::numbers::{FixedTrait, FP8x23}; + +fn input_0() -> Array> { + let mut sequence = ArrayTrait::new(); + + let mut shape = ArrayTrait::::new(); + shape.append(2); + shape.append(2); + + let mut data = ArrayTrait::new(); + data.append(FP8x23 { mag: 33554432, sign: false }); + data.append(FP8x23 { mag: 0, sign: false }); + data.append(FP8x23 { mag: 8388608, sign: true }); + data.append(FP8x23 { mag: 0, sign: false }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(2); + shape.append(2); + + let mut data = ArrayTrait::new(); + data.append(FP8x23 { mag: 25165824, sign: false }); + data.append(FP8x23 { mag: 16777216, sign: true }); + data.append(FP8x23 { mag: 41943040, sign: false }); + data.append(FP8x23 { mag: 41943040, sign: false }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(2); + shape.append(2); + + let mut data = ArrayTrait::new(); + data.append(FP8x23 { mag: 25165824, sign: false }); + data.append(FP8x23 { mag: 41943040, sign: false }); + data.append(FP8x23 { mag: 41943040, sign: false }); + data.append(FP8x23 { mag: 16777216, sign: false }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(2); + shape.append(2); + + let mut data = ArrayTrait::new(); + data.append(FP8x23 { mag: 50331648, sign: true }); + data.append(FP8x23 { mag: 50331648, sign: true }); + data.append(FP8x23 { mag: 8388608, sign: true }); + data.append(FP8x23 { mag: 16777216, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(2); + shape.append(2); + + let mut data = ArrayTrait::new(); + data.append(FP8x23 { mag: 41943040, sign: false }); + data.append(FP8x23 { mag: 41943040, sign: false }); + data.append(FP8x23 { mag: 33554432, sign: false }); + data.append(FP8x23 { mag: 16777216, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + sequence +} diff --git a/tests/nodes/sequence_length_fp8x23/output_0.cairo b/tests/nodes/sequence_length_fp8x23/output_0.cairo new file mode 100644 index 000000000..fa5db15f8 --- /dev/null +++ b/tests/nodes/sequence_length_fp8x23/output_0.cairo @@ -0,0 +1,11 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32Tensor; + +fn output_0() -> Tensor { + let mut shape = ArrayTrait::::new(); + + let mut data = ArrayTrait::new(); + data.append(5); + TensorTrait::new(shape.span(), data.span()) +} diff --git a/tests/nodes/sequence_length_fp8x23_broadcast.cairo b/tests/nodes/sequence_length_fp8x23_broadcast.cairo new file mode 100644 index 000000000..9e8340e55 --- /dev/null +++ b/tests/nodes/sequence_length_fp8x23_broadcast.cairo @@ -0,0 +1,22 @@ +mod input_0; +mod output_0; + + +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::FP8x23TensorPartialEq; +use orion::operators::tensor::FP8x23Tensor; +use orion::operators::tensor::U32TensorPartialEq; +use orion::utils::{assert_eq, assert_seq_eq}; +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::U32Tensor; + +#[test] +#[available_gas(2000000000)] +fn test_sequence_length_fp8x23_broadcast() { + let input_0 = input_0::input_0(); + let z = output_0::output_0(); + + let y = input_0.sequence_length(); + + assert_eq(y, z); +} diff --git a/tests/nodes/sequence_length_fp8x23_broadcast/input_0.cairo b/tests/nodes/sequence_length_fp8x23_broadcast/input_0.cairo new file mode 100644 index 000000000..86c579ca0 --- /dev/null +++ b/tests/nodes/sequence_length_fp8x23_broadcast/input_0.cairo @@ -0,0 +1,20 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::FP8x23Tensor; +use orion::numbers::{FixedTrait, FP8x23}; + +fn input_0() -> Array> { + let mut sequence = ArrayTrait::new(); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(2); + + let mut data = ArrayTrait::new(); + data.append(FP8x23 { mag: 33554432, sign: false }); + data.append(FP8x23 { mag: 50331648, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + sequence +} diff --git a/tests/nodes/sequence_length_fp8x23_broadcast/output_0.cairo b/tests/nodes/sequence_length_fp8x23_broadcast/output_0.cairo new file mode 100644 index 000000000..abdf2e9d5 --- /dev/null +++ b/tests/nodes/sequence_length_fp8x23_broadcast/output_0.cairo @@ -0,0 +1,11 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32Tensor; + +fn output_0() -> Tensor { + let mut shape = ArrayTrait::::new(); + + let mut data = ArrayTrait::new(); + data.append(1); + TensorTrait::new(shape.span(), data.span()) +} diff --git a/tests/nodes/sequence_length_i32.cairo b/tests/nodes/sequence_length_i32.cairo new file mode 100644 index 000000000..005bbc313 --- /dev/null +++ b/tests/nodes/sequence_length_i32.cairo @@ -0,0 +1,22 @@ +mod input_0; +mod output_0; + + +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32TensorPartialEq; +use orion::utils::{assert_eq, assert_seq_eq}; +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::I32Tensor; +use orion::operators::tensor::I32TensorPartialEq; +use orion::operators::tensor::U32Tensor; + +#[test] +#[available_gas(2000000000)] +fn test_sequence_length_i32() { + let input_0 = input_0::input_0(); + let z = output_0::output_0(); + + let y = input_0.sequence_length(); + + assert_eq(y, z); +} diff --git a/tests/nodes/sequence_length_i32/input_0.cairo b/tests/nodes/sequence_length_i32/input_0.cairo new file mode 100644 index 000000000..970397961 --- /dev/null +++ b/tests/nodes/sequence_length_i32/input_0.cairo @@ -0,0 +1,30 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::I32Tensor; +use orion::numbers::{IntegerTrait, i32}; + +fn input_0() -> Array> { + let mut sequence = ArrayTrait::new(); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(2); + + let mut data = ArrayTrait::new(); + data.append(i32 { mag: 3, sign: false }); + data.append(i32 { mag: 6, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(2); + + let mut data = ArrayTrait::new(); + data.append(i32 { mag: 5, sign: true }); + data.append(i32 { mag: 5, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + sequence +} diff --git a/tests/nodes/sequence_length_i32/output_0.cairo b/tests/nodes/sequence_length_i32/output_0.cairo new file mode 100644 index 000000000..8df327a8b --- /dev/null +++ b/tests/nodes/sequence_length_i32/output_0.cairo @@ -0,0 +1,11 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32Tensor; + +fn output_0() -> Tensor { + let mut shape = ArrayTrait::::new(); + + let mut data = ArrayTrait::new(); + data.append(2); + TensorTrait::new(shape.span(), data.span()) +} diff --git a/tests/nodes/sequence_length_i32_broadcast.cairo b/tests/nodes/sequence_length_i32_broadcast.cairo new file mode 100644 index 000000000..5af2cb7af --- /dev/null +++ b/tests/nodes/sequence_length_i32_broadcast.cairo @@ -0,0 +1,22 @@ +mod input_0; +mod output_0; + + +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32TensorPartialEq; +use orion::utils::{assert_eq, assert_seq_eq}; +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::I32Tensor; +use orion::operators::tensor::I32TensorPartialEq; +use orion::operators::tensor::U32Tensor; + +#[test] +#[available_gas(2000000000)] +fn test_sequence_length_i32_broadcast() { + let input_0 = input_0::input_0(); + let z = output_0::output_0(); + + let y = input_0.sequence_length(); + + assert_eq(y, z); +} diff --git a/tests/nodes/sequence_length_i32_broadcast/input_0.cairo b/tests/nodes/sequence_length_i32_broadcast/input_0.cairo new file mode 100644 index 000000000..4588ce948 --- /dev/null +++ b/tests/nodes/sequence_length_i32_broadcast/input_0.cairo @@ -0,0 +1,56 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::I32Tensor; +use orion::numbers::{IntegerTrait, i32}; + +fn input_0() -> Array> { + let mut sequence = ArrayTrait::new(); + + let mut shape = ArrayTrait::::new(); + shape.append(2); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(i32 { mag: 4, sign: false }); + data.append(i32 { mag: 2, sign: false }); + data.append(i32 { mag: 0, sign: false }); + data.append(i32 { mag: 6, sign: true }); + data.append(i32 { mag: 5, sign: true }); + data.append(i32 { mag: 1, sign: false }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(i32 { mag: 4, sign: true }); + data.append(i32 { mag: 3, sign: false }); + data.append(i32 { mag: 1, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(3); + shape.append(1); + + let mut data = ArrayTrait::new(); + data.append(i32 { mag: 5, sign: false }); + data.append(i32 { mag: 5, sign: true }); + data.append(i32 { mag: 6, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(2); + shape.append(1); + + let mut data = ArrayTrait::new(); + data.append(i32 { mag: 2, sign: false }); + data.append(i32 { mag: 5, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + sequence +} diff --git a/tests/nodes/sequence_length_i32_broadcast/output_0.cairo b/tests/nodes/sequence_length_i32_broadcast/output_0.cairo new file mode 100644 index 000000000..0e770ce74 --- /dev/null +++ b/tests/nodes/sequence_length_i32_broadcast/output_0.cairo @@ -0,0 +1,11 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32Tensor; + +fn output_0() -> Tensor { + let mut shape = ArrayTrait::::new(); + + let mut data = ArrayTrait::new(); + data.append(4); + TensorTrait::new(shape.span(), data.span()) +} diff --git a/tests/nodes/sequence_length_i8.cairo b/tests/nodes/sequence_length_i8.cairo new file mode 100644 index 000000000..db9b7fbe6 --- /dev/null +++ b/tests/nodes/sequence_length_i8.cairo @@ -0,0 +1,22 @@ +mod input_0; +mod output_0; + + +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32TensorPartialEq; +use orion::utils::{assert_eq, assert_seq_eq}; +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::U32Tensor; +use orion::operators::tensor::I8TensorPartialEq; +use orion::operators::tensor::I8Tensor; + +#[test] +#[available_gas(2000000000)] +fn test_sequence_length_i8() { + let input_0 = input_0::input_0(); + let z = output_0::output_0(); + + let y = input_0.sequence_length(); + + assert_eq(y, z); +} diff --git a/tests/nodes/sequence_length_i8/input_0.cairo b/tests/nodes/sequence_length_i8/input_0.cairo new file mode 100644 index 000000000..5a91461ac --- /dev/null +++ b/tests/nodes/sequence_length_i8/input_0.cairo @@ -0,0 +1,52 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::I8Tensor; +use orion::numbers::{IntegerTrait, i8}; + +fn input_0() -> Array> { + let mut sequence = ArrayTrait::new(); + + let mut shape = ArrayTrait::::new(); + shape.append(2); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(i8 { mag: 3, sign: true }); + data.append(i8 { mag: 1, sign: false }); + data.append(i8 { mag: 3, sign: false }); + data.append(i8 { mag: 3, sign: false }); + data.append(i8 { mag: 2, sign: false }); + data.append(i8 { mag: 6, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(2); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(i8 { mag: 1, sign: true }); + data.append(i8 { mag: 5, sign: false }); + data.append(i8 { mag: 0, sign: false }); + data.append(i8 { mag: 1, sign: true }); + data.append(i8 { mag: 3, sign: false }); + data.append(i8 { mag: 5, sign: false }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(2); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(i8 { mag: 1, sign: false }); + data.append(i8 { mag: 2, sign: true }); + data.append(i8 { mag: 5, sign: true }); + data.append(i8 { mag: 5, sign: true }); + data.append(i8 { mag: 2, sign: true }); + data.append(i8 { mag: 4, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + sequence +} diff --git a/tests/nodes/sequence_length_i8/output_0.cairo b/tests/nodes/sequence_length_i8/output_0.cairo new file mode 100644 index 000000000..08a3d1576 --- /dev/null +++ b/tests/nodes/sequence_length_i8/output_0.cairo @@ -0,0 +1,11 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32Tensor; + +fn output_0() -> Tensor { + let mut shape = ArrayTrait::::new(); + + let mut data = ArrayTrait::new(); + data.append(3); + TensorTrait::new(shape.span(), data.span()) +} diff --git a/tests/nodes/sequence_length_i8_broadcast.cairo b/tests/nodes/sequence_length_i8_broadcast.cairo new file mode 100644 index 000000000..a67bc0c0f --- /dev/null +++ b/tests/nodes/sequence_length_i8_broadcast.cairo @@ -0,0 +1,22 @@ +mod input_0; +mod output_0; + + +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32TensorPartialEq; +use orion::utils::{assert_eq, assert_seq_eq}; +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::U32Tensor; +use orion::operators::tensor::I8TensorPartialEq; +use orion::operators::tensor::I8Tensor; + +#[test] +#[available_gas(2000000000)] +fn test_sequence_length_i8_broadcast() { + let input_0 = input_0::input_0(); + let z = output_0::output_0(); + + let y = input_0.sequence_length(); + + assert_eq(y, z); +} diff --git a/tests/nodes/sequence_length_i8_broadcast/input_0.cairo b/tests/nodes/sequence_length_i8_broadcast/input_0.cairo new file mode 100644 index 000000000..71aca8901 --- /dev/null +++ b/tests/nodes/sequence_length_i8_broadcast/input_0.cairo @@ -0,0 +1,62 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::I8Tensor; +use orion::numbers::{IntegerTrait, i8}; + +fn input_0() -> Array> { + let mut sequence = ArrayTrait::new(); + + let mut shape = ArrayTrait::::new(); + shape.append(3); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(i8 { mag: 6, sign: true }); + data.append(i8 { mag: 3, sign: false }); + data.append(i8 { mag: 6, sign: true }); + data.append(i8 { mag: 5, sign: false }); + data.append(i8 { mag: 4, sign: false }); + data.append(i8 { mag: 2, sign: true }); + data.append(i8 { mag: 0, sign: false }); + data.append(i8 { mag: 3, sign: false }); + data.append(i8 { mag: 4, sign: false }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(1); + + let mut data = ArrayTrait::new(); + data.append(i8 { mag: 3, sign: false }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(3); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(i8 { mag: 4, sign: true }); + data.append(i8 { mag: 5, sign: true }); + data.append(i8 { mag: 1, sign: false }); + data.append(i8 { mag: 4, sign: true }); + data.append(i8 { mag: 4, sign: true }); + data.append(i8 { mag: 1, sign: true }); + data.append(i8 { mag: 4, sign: true }); + data.append(i8 { mag: 5, sign: false }); + data.append(i8 { mag: 6, sign: true }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(1); + + let mut data = ArrayTrait::new(); + data.append(i8 { mag: 4, sign: false }); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + sequence +} diff --git a/tests/nodes/sequence_length_i8_broadcast/output_0.cairo b/tests/nodes/sequence_length_i8_broadcast/output_0.cairo new file mode 100644 index 000000000..0e770ce74 --- /dev/null +++ b/tests/nodes/sequence_length_i8_broadcast/output_0.cairo @@ -0,0 +1,11 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32Tensor; + +fn output_0() -> Tensor { + let mut shape = ArrayTrait::::new(); + + let mut data = ArrayTrait::new(); + data.append(4); + TensorTrait::new(shape.span(), data.span()) +} diff --git a/tests/nodes/sequence_length_u32.cairo b/tests/nodes/sequence_length_u32.cairo new file mode 100644 index 000000000..0ba4c2b79 --- /dev/null +++ b/tests/nodes/sequence_length_u32.cairo @@ -0,0 +1,20 @@ +mod input_0; +mod output_0; + + +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32TensorPartialEq; +use orion::utils::{assert_eq, assert_seq_eq}; +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::U32Tensor; + +#[test] +#[available_gas(2000000000)] +fn test_sequence_length_u32() { + let input_0 = input_0::input_0(); + let z = output_0::output_0(); + + let y = input_0.sequence_length(); + + assert_eq(y, z); +} diff --git a/tests/nodes/sequence_length_u32/input_0.cairo b/tests/nodes/sequence_length_u32/input_0.cairo new file mode 100644 index 000000000..f0a5cf3c2 --- /dev/null +++ b/tests/nodes/sequence_length_u32/input_0.cairo @@ -0,0 +1,26 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32Tensor; + +fn input_0() -> Array> { + let mut sequence = ArrayTrait::new(); + + let mut shape = ArrayTrait::::new(); + shape.append(3); + shape.append(3); + + let mut data = ArrayTrait::new(); + data.append(5); + data.append(1); + data.append(4); + data.append(0); + data.append(2); + data.append(4); + data.append(1); + data.append(3); + data.append(1); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + sequence +} diff --git a/tests/nodes/sequence_length_u32/output_0.cairo b/tests/nodes/sequence_length_u32/output_0.cairo new file mode 100644 index 000000000..abdf2e9d5 --- /dev/null +++ b/tests/nodes/sequence_length_u32/output_0.cairo @@ -0,0 +1,11 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32Tensor; + +fn output_0() -> Tensor { + let mut shape = ArrayTrait::::new(); + + let mut data = ArrayTrait::new(); + data.append(1); + TensorTrait::new(shape.span(), data.span()) +} diff --git a/tests/nodes/sequence_length_u32_broadcast.cairo b/tests/nodes/sequence_length_u32_broadcast.cairo new file mode 100644 index 000000000..17f8f3474 --- /dev/null +++ b/tests/nodes/sequence_length_u32_broadcast.cairo @@ -0,0 +1,20 @@ +mod input_0; +mod output_0; + + +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32TensorPartialEq; +use orion::utils::{assert_eq, assert_seq_eq}; +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::U32Tensor; + +#[test] +#[available_gas(2000000000)] +fn test_sequence_length_u32_broadcast() { + let input_0 = input_0::input_0(); + let z = output_0::output_0(); + + let y = input_0.sequence_length(); + + assert_eq(y, z); +} diff --git a/tests/nodes/sequence_length_u32_broadcast/input_0.cairo b/tests/nodes/sequence_length_u32_broadcast/input_0.cairo new file mode 100644 index 000000000..a1ff2ed88 --- /dev/null +++ b/tests/nodes/sequence_length_u32_broadcast/input_0.cairo @@ -0,0 +1,19 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32Tensor; + +fn input_0() -> Array> { + let mut sequence = ArrayTrait::new(); + + let mut shape = ArrayTrait::::new(); + shape.append(1); + shape.append(2); + + let mut data = ArrayTrait::new(); + data.append(3); + data.append(1); + + sequence.append(TensorTrait::new(shape.span(), data.span())); + + sequence +} diff --git a/tests/nodes/sequence_length_u32_broadcast/output_0.cairo b/tests/nodes/sequence_length_u32_broadcast/output_0.cairo new file mode 100644 index 000000000..abdf2e9d5 --- /dev/null +++ b/tests/nodes/sequence_length_u32_broadcast/output_0.cairo @@ -0,0 +1,11 @@ +use array::{ArrayTrait, SpanTrait}; +use orion::operators::tensor::{TensorTrait, Tensor}; +use orion::operators::tensor::U32Tensor; + +fn output_0() -> Tensor { + let mut shape = ArrayTrait::::new(); + + let mut data = ArrayTrait::new(); + data.append(1); + TensorTrait::new(shape.span(), data.span()) +} From a791f4673561f0362a82f8164abbb802160aa252 Mon Sep 17 00:00:00 2001 From: "Thomas S. Bauer" Date: Wed, 15 Nov 2023 13:55:17 +0100 Subject: [PATCH 3/3] Add docs --- docs/SUMMARY.md | 1 + docs/framework/compatibility.md | 3 +- docs/framework/operators/tensor/README.md | 1 + .../tensor/tensor.sequence_length.md | 36 ++++++++++++++++++ src/operators/tensor/core.cairo | 38 ++++++++++++++++++- .../tensor/math/sequence_length.cairo | 1 + 6 files changed, 78 insertions(+), 2 deletions(-) create mode 100644 docs/framework/operators/tensor/tensor.sequence_length.md diff --git a/docs/SUMMARY.md b/docs/SUMMARY.md index 8db15644a..2649a0abc 100644 --- a/docs/SUMMARY.md +++ b/docs/SUMMARY.md @@ -100,6 +100,7 @@ * [tensor.reduce\_sum\_square](framework/operators/tensor/tensor.reduce\_sum\_square.md) * [tensor.reduce\_l2](framework/operators/tensor/tensor.reduce\_l2.md) * [tensor.reduce\_l1](framework/operators/tensor/tensor.reduce\_l1.md) + * [tensor.sequence\_length](framework/operators/tensor/tensor.sequence\_length.md) * [Neural Network](framework/operators/neural-network/README.md) * [nn.relu](framework/operators/neural-network/nn.relu.md) * [nn.leaky\_relu](framework/operators/neural-network/nn.leaky\_relu.md) diff --git a/docs/framework/compatibility.md b/docs/framework/compatibility.md index ebc50ad77..1111f0e11 100644 --- a/docs/framework/compatibility.md +++ b/docs/framework/compatibility.md @@ -81,5 +81,6 @@ You can see below the list of current supported ONNX Operators: | [ConstantOfShape](operators/tensor/tensor.constant_of_shape.md) | :white\_check\_mark: | | [ReduceL1](operators/tensor/tensor.reduce\_l1.md) | :white\_check\_mark: | | [ReduceL2](operators/tensor/tensor.reduce\_l2.md) | :white\_check\_mark: | +| [SequenceLength](operators/tensor/tensor.sequence\_length.md) | :white\_check\_mark: | -Current Operators support: **75/156 (48%)** +Current Operators support: **76/156 (49%)** diff --git a/docs/framework/operators/tensor/README.md b/docs/framework/operators/tensor/README.md index d793cc692..25ed8dcc6 100644 --- a/docs/framework/operators/tensor/README.md +++ b/docs/framework/operators/tensor/README.md @@ -98,6 +98,7 @@ use orion::operators::tensor::TensorTrait; | [`tensor.scatter`](tensor.scatter.md) | Produces a copy of input data, and updates value to values specified by updates at specific index positions specified by indices. | | [`tensor.reduce_sum_square`](tensor.reduce\_sum\_square.md) | Computes the sum square of the input tensor's elements along the provided axes. | | [`tensor.reduce_l2`](tensor.reduce\_l2.md) | Computes the L2 norm of the input tensor's elements along the provided axes. | +| [`tensor.sequence_length`](tensor.sequence\_length.md) | Returns the length of the input sequence. | ## Arithmetic Operations diff --git a/docs/framework/operators/tensor/tensor.sequence_length.md b/docs/framework/operators/tensor/tensor.sequence_length.md new file mode 100644 index 000000000..8a18c14ff --- /dev/null +++ b/docs/framework/operators/tensor/tensor.sequence_length.md @@ -0,0 +1,36 @@ +# tensor.sequence_length + +```rust + fn sequence_length(self: Array>) -> Tensor; +``` + +Returns the length of the input sequence. + +## Args + +* `self`(`Array>`) - The input sequence. + +## Returns + +The length of the sequence as scalar, i.e. a tensor of shape []. + +## Examples + +Let's create new u32 Tensor with constant 42. + +```rust +let mut sequence = ArrayTrait::new(); + +let mut shape = ArrayTrait::::new(); +shape.append(1); +shape.append(2); + +let mut data = ArrayTrait::new(); +data.append(3); +data.append(1); + +sequence.append(TensorTrait::new(shape.span(), data.span())); + +sequence.sequence_length() +>>> [1] +``` diff --git a/src/operators/tensor/core.cairo b/src/operators/tensor/core.cairo index 872117142..61ed62742 100644 --- a/src/operators/tensor/core.cairo +++ b/src/operators/tensor/core.cairo @@ -3585,7 +3585,43 @@ trait TensorTrait { /// ``` /// fn constant_of_shape(shape: Span, value: T) -> Tensor; - /// TODO + /// # tensor.sequence_length + /// + /// ```rust + /// fn sequence_length(self: Array>) -> Tensor; + /// ``` + /// + /// Returns the length of the input sequence. + /// + /// ## Args + /// + /// * `self`(`Array>`) - The input sequence. + /// + /// ## Returns + /// + /// The length of the sequence as scalar, i.e. a tensor of shape []. + /// + /// ## Examples + /// + /// Let's create new u32 Tensor with constant 42. + /// + /// ```rust + /// let mut sequence = ArrayTrait::new(); + /// + /// let mut shape = ArrayTrait::::new(); + /// shape.append(1); + /// shape.append(2); + /// + /// let mut data = ArrayTrait::new(); + /// data.append(3); + /// data.append(1); + /// + /// sequence.append(TensorTrait::new(shape.span(), data.span())); + /// + /// sequence.sequence_length() + /// >>> [1] + /// ``` + /// fn sequence_length(self: Array>) -> Tensor; } diff --git a/src/operators/tensor/math/sequence_length.cairo b/src/operators/tensor/math/sequence_length.cairo index 36aacae5a..65feeab43 100644 --- a/src/operators/tensor/math/sequence_length.cairo +++ b/src/operators/tensor/math/sequence_length.cairo @@ -3,6 +3,7 @@ use array::{ArrayTrait, SpanTrait}; use orion::operators::tensor::{TensorTrait, Tensor}; +/// Cf: TensorTrait::sequence_length docstring fn sequence_length>(self: Array>) -> Tensor { let mut shape = ArrayTrait::::new(); let mut result = ArrayTrait::new();