text
stringlengths 1
2.05k
|
|---|
fn axis_0() {
let tensor = u32_tensor_2x2x2_helper();
let result = tensor.flatten(0);
assert((*result.shape[0]).into() == 1, 'result[0] = 1');
assert((*result.shape[1]).into() == 8, 'result[1] = 8');
} |
fn axis_1() {
let tensor = u32_tensor_2x2x2_helper();
let result = tensor.flatten(1);
assert((*result.shape[0]).into() == 2, 'result[0] = 2');
assert((*result.shape[1]).into() == 4, 'result[1] = 4');
} |
fn axis_2() {
let tensor = u32_tensor_2x2x2_helper();
let result = tensor.flatten(2);
assert((*result.shape[0]).into() == 4, 'result[0] = 4');
assert((*result.shape[1]).into() == 2, 'result[1] = 2');
}
} |
mod max_u32_test;
mod max_i32_test;
mod max_fp_test;
|
mod max_fp8x23_test;
mod max_fp16x16_test;
|
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_1x3_helper;
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = fp_tensor_1x3_helper();
let result = tensor.max_in_tensor().mag;
assert(result == FixedTrait::<FP16x16>::new_unscaled(2, false).mag, 'tensor.max = 2');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2_helper;
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.max_in_tensor().mag;
assert(result == FixedTrait::<FP16x16>::new_unscaled(3, false).mag, 'tensor.max = 3');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2x2_helper;
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.max_in_tensor().mag;
assert(result == FixedTrait::<FP16x16>::new_unscaled(7, false).mag, 'tensor.max = 7');
}
}
|
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_1x3_helper;
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = fp_tensor_1x3_helper();
let result = tensor.max_in_tensor().mag;
assert(result == FixedTrait::<FP8x23>::new_unscaled(2, false).mag, 'tensor.max = 2');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2_helper;
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.max_in_tensor().mag;
assert(result == FixedTrait::<FP8x23>::new_unscaled(3, false).mag, 'tensor.max = 3');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2x2_helper;
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.max_in_tensor().mag;
assert(result == FixedTrait::<FP8x23>::new_unscaled(7, false).mag, 'tensor.max = 7');
}
}
|
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::i32::i32_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = i32_tensor_1x3_helper();
let result = tensor.max_in_tensor();
assert(result == 2, 'tensor.max = 2');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::i32::i32_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = i32_tensor_2x2_helper();
let result = tensor.max_in_tensor();
assert(result == 3, 'tensor.max = 3');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::i32::i32_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = i32_tensor_2x2x2_helper();
let result = tensor.max_in_tensor();
assert(result == 7, 'tensor.max = 7');
}
}
|
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::u32::u32_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = u32_tensor_1x3_helper();
let result = tensor.max_in_tensor();
assert(result == 2, 'tensor.max = 2');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::u32::u32_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = u32_tensor_2x2_helper();
let result = tensor.max_in_tensor();
assert(result == 3, 'tensor.max = 3');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::u32::u32_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = u32_tensor_2x2x2_helper();
let result = tensor.max_in_tensor();
assert(result == 7, 'tensor.max = 7');
}
}
|
mod min_u32_test;
mod min_i32_test;
mod min_fp_test;
|
mod min_fp8x23_test;
mod min_fp16x16_test;
|
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_1x3_helper;
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16Impl;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = fp_tensor_1x3_helper();
let result = tensor.min_in_tensor().mag;
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2_helper;
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16Impl;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.min_in_tensor().mag;
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2x2_helper;
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16Impl;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.min_in_tensor().mag;
assert(result == 0, 'tensor.min = 0');
}
}
|
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_1x3_helper;
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23Impl;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = fp_tensor_1x3_helper();
let result = tensor.min_in_tensor().mag;
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2_helper;
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23Impl;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.min_in_tensor().mag;
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2x2_helper;
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23Impl;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.min_in_tensor().mag;
assert(result == 0, 'tensor.min = 0');
}
}
|
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::i32::i32_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = i32_tensor_1x3_helper();
let result = tensor.min_in_tensor();
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::i32::i32_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = i32_tensor_2x2_helper();
let result = tensor.min_in_tensor();
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::i32::i32_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = i32_tensor_2x2x2_helper();
let result = tensor.min_in_tensor();
assert(result == 0, 'tensor.min = 0');
}
}
|
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::u32::u32_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = u32_tensor_1x3_helper();
let result = tensor.min_in_tensor();
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::u32::u32_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = u32_tensor_2x2_helper();
let result = tensor.min_in_tensor();
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::u32::u32_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = u32_tensor_2x2x2_helper();
let result = tensor.min_in_tensor();
assert(result == 0, 'tensor.min = 0');
}
}
|
mod onehot_fp_test;
|
mod onehot_fp8x23_test;
mod onehot_fp16x16_test;
|
use core::serde::Serde;
use core::option::OptionTrait;
use core::clone::Clone;
use orion::numbers::fixed_point::core::FixedTrait;
mod tensor_1D {
use core::array::{ArrayTrait, SpanTrait};
use core::traits::Into;
use orion::numbers::fixed_point::core::{FixedTrait};
use orion::numbers::fixed_point::implementations::fp16x16::core::{FP16x16, FP16x16PartialEq};
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::test_helper::tensor::fixed_point::fp16x16::{
fp_tensor_1x3_helper, fp_tensor_2x2_helper, fp_tensor_3x2x2_neg_helper,
fp_tensor_1x3_neg_helper, fp_tensor_2x2x2_helper
};
use orion::operators::tensor::core::TensorTrait;
use core::debug::PrintTrait;
use core::clone::Clone;
use core::option::OptionTrait;
use core::serde::Serde;
use orion::operators::tensor::core::{Tensor};
fn fp_tensor_3x2x2_new() -> Tensor<FP16x16> {
let mut sizes = ArrayTrait::new();
sizes.append(3);
sizes.append(2);
sizes.append(2);
let mut data = ArrayTrait::new();
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
let tensor = TensorTrait::<FP16x16>::new(sizes.span(), data.span());
return tensor;
}
fn fp_tensor_2x2_pos_neg_new() -> Tensor<FP16x16> {
let mut sizes = ArrayTrait::new();
sizes.append(2);
sizes.app |
end(2);
let mut data = ArrayTrait::new();
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, true));
data.append(FixedTrait::new_unscaled(1, true));
let tensor = TensorTrait::<FP16x16>::new(sizes.span(), data.span());
return tensor;
} |
fn tensor_onehot_1x3_last_axis() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(1, false), 'result[8] = 1');
} |
fn tensor_onehot_1x3_neg_last_axis() {
let tensor = fp_tensor_1x3_neg_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(1, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 1');
} |
fn tensor_onehot_2x2_post_neg_last_axis() {
let tensor = fp_tensor_2x2_pos_neg_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(1, false), 'result[7] = 1');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(0, false), 'result[10] = 0');
assert((*result.data[11]) == FixedTrait::new_unscaled(1, false), 'result[11] = 0');
} |
fn tensor_onehot_tensor_1x3_fail() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::Some(3);
let _result = tensor.onehot(depth: depth, axis: axis, values: values.span());
} |
fn tensor_onehot_1x3_Zero_axis() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::Some(0);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(1, false), 'result[8] = 1');
} |
fn tensor_onehot_1x3_axis_one() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::Some(1);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(1, false), 'result[8] = 1');
} |
fn fp_tensor_onehot_2x2_helper_last_axis() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.shape.at(0)) == 2, 'shape[0] = 2');
assert((*result.shape.at(1)) == 2, 'shape[0] = 2');
assert((*result.shape.at(2)) == 4, 'shape[0] = 4');
} |
fn tensor_onehot_tensor_2x2_fail() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(3);
let _result = tensor.onehot(depth: depth, axis: axis, values: values.span());
} |
fn fp_tensor_onehot_2x2_helper_first_axis() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(0);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.shape.at(0)) == 4, 'shape[0] = 4');
assert((*result.shape.at(1)) == 2, 'shape[0] = 2');
assert((*result.shape.at(2)) == 2, 'shape[0] = 2');
} |
fn fp_tensor_onehot_2x2_helper_second_axis() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(1);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(1, false), 'result[3] = 1');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(0, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(1, false), 'result[12] = 1');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.shape.at(0)) == 2, 'shape[0] = 2');
assert((*result.shape.at(1)) == 4, 'shape[0] = 4');
assert((*result.shape.at(2)) == 2, 'shape[0] = 2');
} |
fn fp_tensor_onehot_3x2x2_new_last_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.data[16]) == FixedTrait::new_unscaled(1, false), 'result[16] = 1');
assert((*result.data[21]) == FixedTrait::new_unscaled(1, false), 'result[21] = 1');
assert((*result.data[26]) == FixedTrait::new_uns |
caled(1, false), 'result[26] = 1');
assert((*result.data[31]) == FixedTrait::new_unscaled(1, false), 'result[31] = 1');
assert((*result.data[32]) == FixedTrait::new_unscaled(1, false), 'result[32] = 1');
assert((*result.data[37]) == FixedTrait::new_unscaled(1, false), 'result[37] = 1');
assert((*result.data[42]) == FixedTrait::new_unscaled(1, false), 'result[42] = 1');
assert((*result.data[46]) == FixedTrait::new_unscaled(0, false), 'result[46] = 0');
assert((*result.data[47]) == FixedTrait::new_unscaled(1, false), 'result[47] = 1');
assert((*result.shape.at(0)) == 3, 'shape[0] = 3');
assert((*result.shape.at(1)) == 2, 'shape[1] = 2');
assert((*result.shape.at(2)) == 2, 'shape[2] = 2');
assert((*result.shape.at(3)) == 4, 'shape[0] = 4');
} |
fn tensor_onehot_tensor_3x2x2_fail() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(4);
let _result = tensor.onehot(depth: depth, axis: axis, values: values.span());
} |
fn fp_tensor_onehot_3x2x2_new_first_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(2);
values.append(5);
let depth = 4;
let axis: Option<usize> = Option::Some(0);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(5, false), 'result[0] = 5');
assert((*result.data[1]) == FixedTrait::new_unscaled(2, false), 'result[1] = 2');
assert((*result.data[2]) == FixedTrait::new_unscaled(2, false), 'result[2] = 2');
assert((*result.data[3]) == FixedTrait::new_unscaled(2, false), 'result[3] = 2');
assert((*result.data[4]) == FixedTrait::new_unscaled(5, false), 'result[4] = 5');
assert((*result.data[5]) == FixedTrait::new_unscaled(2, false), 'result[5] = 2');
assert((*result.data[6]) == FixedTrait::new_unscaled(2, false), 'result[6] = 2');
assert((*result.data[7]) == FixedTrait::new_unscaled(2, false), 'result[7] = 2');
assert((*result.data[8]) == FixedTrait::new_unscaled(5, false), 'result[8] = 5');
assert((*result.data[9]) == FixedTrait::new_unscaled(2, false), 'result[9] = 2');
assert((*result.data[10]) == FixedTrait::new_unscaled(2, false), 'result[10] = 2');
assert((*result.data[11]) == FixedTrait::new_unscaled(2, false), 'result[11] = 2');
assert((*result.data[12]) == FixedTrait::new_unscaled(2, false), 'result[12] = 2');
assert((*result.data[13]) == FixedTrait::new_unscaled(5, false), 'result[13] = 5');
assert((*result.data[14]) == FixedTrait::new_unscaled(2, false), 'result[14] = 2');
assert((*result.data[17]) == FixedTrait::new_unscaled(5, false), 'result[17] = 5');
assert((*result.data[21]) == FixedTrait::new_unscaled(5, false), 'result[21] = 5');
assert((*result.data[26]) == FixedTrait::new_unscaled(5, false), 'result[26] = 5');
assert((*result.data[30]) == FixedTrait::new_unscaled(5, |
false), 'result[30] = 5');
assert((*result.data[34]) == FixedTrait::new_unscaled(5, false), 'result[34] = 5');
assert((*result.data[39]) == FixedTrait::new_unscaled(5, false), 'result[39] = 5');
assert((*result.data[43]) == FixedTrait::new_unscaled(5, false), 'result[43] = 5');
assert((*result.data[46]) == FixedTrait::new_unscaled(2, false), 'result[46] = 2');
assert((*result.data[47]) == FixedTrait::new_unscaled(5, false), 'result[47] = 5');
assert((*result.shape.at(0)) == 4, 'shape[0] = 4');
assert((*result.shape.at(1)) == 3, 'shape[1] = 3');
assert((*result.shape.at(2)) == 2, 'shape[2] = 3');
assert((*result.shape.at(3)) == 2, 'shape[0] = 2');
} |
fn fp_tensor_onehot_3x2x2_new_second_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(1);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.data[16]) == FixedTrait::new_unscaled(1, false), 'result[16] = 1');
assert((*result.data[21]) == FixedTrait::new_unscaled(1, false), 'result[21] = 1');
assert((*result.data[26]) == FixedTrait::new_unscaled(1, |
false), 'result[26] = 1');
assert((*result.data[31]) == FixedTrait::new_unscaled(1, false), 'result[31] = 1');
assert((*result.data[32]) == FixedTrait::new_unscaled(1, false), 'result[32] = 1');
assert((*result.data[37]) == FixedTrait::new_unscaled(1, false), 'result[37] = 1');
assert((*result.data[42]) == FixedTrait::new_unscaled(1, false), 'result[42] = 1');
assert((*result.data[46]) == FixedTrait::new_unscaled(0, false), 'result[46] = 0');
assert((*result.data[47]) == FixedTrait::new_unscaled(1, false), 'result[47] = 1');
assert((*result.shape.at(0)) == 3, 'shape[0] = 3');
assert((*result.shape.at(1)) == 4, 'shape[1] = 4');
assert((*result.shape.at(2)) == 2, 'shape[2] = 3');
assert((*result.shape.at(3)) == 2, 'shape[0] = 2');
} |
fn fp_tensor_onehot_3x2x2_new_third_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(2);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(1, false), 'result[3] = 1');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(1, false), 'result[12] = 1');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.data[16]) == FixedTrait::new_unscaled(1, false), 'result[16] = 1');
assert((*result.data[19]) == FixedTrait::new_unscaled(1, false), 'result[19] = 1');
assert((*result.data[21]) == FixedTrait::new_unscaled(0, false), 'result[21] = 0');
assert((*result.data[26]) == FixedTrait::new_unscaled(0, false), 'result[26] = 0');
assert((*result.data[28]) == FixedTrait::new_unscaled(1, false), 'result[28] = 1');
assert((*result.data[31]) == FixedTrait::new_unscaled(1, false), 'result[31] = 1');
assert((*result.data[32]) == FixedTrait::new_unscaled(1, false), 'result[32] = 1');
assert((*result.data[35]) == FixedTrait::new_unscal |
ed(1, false), 'result[35] = 1');
assert((*result.data[37]) == FixedTrait::new_unscaled(0, false), 'result[37] = 0');
assert((*result.data[44]) == FixedTrait::new_unscaled(1, false), 'result[44] = 1');
assert((*result.data[46]) == FixedTrait::new_unscaled(0, false), 'result[46] = 0');
assert((*result.data[47]) == FixedTrait::new_unscaled(1, false), 'result[47] = 1');
assert((*result.shape.at(0)) == 3, 'shape[0] = 3');
assert((*result.shape.at(1)) == 2, 'shape[1] = 2');
assert((*result.shape.at(2)) == 4, 'shape[2] = 4');
assert((*result.shape.at(3)) == 2, 'shape[0] = 2');
}
} |
use core::serde::Serde;
use core::option::OptionTrait;
use core::clone::Clone;
use orion::numbers::fixed_point::core::FixedTrait;
mod tensor_1D {
use core::array::{ArrayTrait, SpanTrait};
use core::traits::Into;
use orion::numbers::fixed_point::core::{FixedTrait};
use orion::numbers::fixed_point::implementations::fp8x23::core::{FP8x23, FP8x23PartialEq};
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::{
fp_tensor_1x3_helper, fp_tensor_2x2_helper, fp_tensor_3x2x2_neg_helper,
fp_tensor_1x3_neg_helper, fp_tensor_2x2x2_helper
};
use core::debug::PrintTrait;
use core::clone::Clone;
use core::option::OptionTrait;
use core::serde::Serde;
use orion::operators::tensor::core::{Tensor};
fn fp_tensor_3x2x2_new() -> Tensor<FP8x23> {
let mut sizes = ArrayTrait::new();
sizes.append(3);
sizes.append(2);
sizes.append(2);
let mut data = ArrayTrait::new();
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
let tensor = TensorTrait::<FP8x23>::new(sizes.span(), data.span());
return tensor;
}
fn fp_tensor_2x2_pos_neg_new() -> Tensor<FP8x23> {
let mut sizes = ArrayTrait::new();
sizes.append(2);
sizes.append(2);
le |
t mut data = ArrayTrait::new();
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, true));
data.append(FixedTrait::new_unscaled(1, true));
let tensor = TensorTrait::<FP8x23>::new(sizes.span(), data.span());
return tensor;
} |
fn tensor_onehot_1x3_last_axis() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(1, false), 'result[8] = 1');
} |
fn tensor_onehot_1x3_neg_last_axis() {
let tensor = fp_tensor_1x3_neg_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(1, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 1');
} |
fn tensor_onehot_2x2_post_neg_last_axis() {
let tensor = fp_tensor_2x2_pos_neg_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(1, false), 'result[7] = 1');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(0, false), 'result[10] = 0');
assert((*result.data[11]) == FixedTrait::new_unscaled(1, false), 'result[11] = 0');
} |
fn tensor_onehot_tensor_1x3_fail() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::Some(3);
let _result = tensor.onehot(depth: depth, axis: axis, values: values.span());
} |
fn tensor_onehot_1x3_Zero_axis() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::Some(0);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(1, false), 'result[8] = 1');
} |
fn tensor_onehot_1x3_axis_one() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::Some(1);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(1, false), 'result[8] = 1');
} |
fn fp_tensor_onehot_2x2_helper_last_axis() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.shape.at(0)) == 2, 'shape[0] = 2');
assert((*result.shape.at(1)) == 2, 'shape[0] = 2');
assert((*result.shape.at(2)) == 4, 'shape[0] = 4');
} |
fn tensor_onehot_tensor_2x2_fail() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(3);
let _result = tensor.onehot(depth: depth, axis: axis, values: values.span());
} |
fn fp_tensor_onehot_2x2_helper_first_axis() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(0);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.shape.at(0)) == 4, 'shape[0] = 4');
assert((*result.shape.at(1)) == 2, 'shape[0] = 2');
assert((*result.shape.at(2)) == 2, 'shape[0] = 2');
} |
fn fp_tensor_onehot_2x2_helper_second_axis() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(1);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(1, false), 'result[3] = 1');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(0, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(1, false), 'result[12] = 1');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.shape.at(0)) == 2, 'shape[0] = 2');
assert((*result.shape.at(1)) == 4, 'shape[0] = 4');
assert((*result.shape.at(2)) == 2, 'shape[0] = 2');
} |
fn fp_tensor_onehot_3x2x2_new_last_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.data[16]) == FixedTrait::new_unscaled(1, false), 'result[16] = 1');
assert((*result.data[21]) == FixedTrait::new_unscaled(1, false), 'result[21] = 1');
assert((*result.data[26]) == FixedTrait::new_uns |
caled(1, false), 'result[26] = 1');
assert((*result.data[31]) == FixedTrait::new_unscaled(1, false), 'result[31] = 1');
assert((*result.data[32]) == FixedTrait::new_unscaled(1, false), 'result[32] = 1');
assert((*result.data[37]) == FixedTrait::new_unscaled(1, false), 'result[37] = 1');
assert((*result.data[42]) == FixedTrait::new_unscaled(1, false), 'result[42] = 1');
assert((*result.data[46]) == FixedTrait::new_unscaled(0, false), 'result[46] = 0');
assert((*result.data[47]) == FixedTrait::new_unscaled(1, false), 'result[47] = 1');
assert((*result.shape.at(0)) == 3, 'shape[0] = 3');
assert((*result.shape.at(1)) == 2, 'shape[1] = 2');
assert((*result.shape.at(2)) == 2, 'shape[2] = 2');
assert((*result.shape.at(3)) == 4, 'shape[0] = 4');
} |
fn tensor_onehot_tensor_3x2x2_fail() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(4);
let _result = tensor.onehot(depth: depth, axis: axis, values: values.span());
} |
fn fp_tensor_onehot_3x2x2_new_first_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(2);
values.append(5);
let depth = 4;
let axis: Option<usize> = Option::Some(0);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(5, false), 'result[0] = 5');
assert((*result.data[1]) == FixedTrait::new_unscaled(2, false), 'result[1] = 2');
assert((*result.data[2]) == FixedTrait::new_unscaled(2, false), 'result[2] = 2');
assert((*result.data[3]) == FixedTrait::new_unscaled(2, false), 'result[3] = 2');
assert((*result.data[4]) == FixedTrait::new_unscaled(5, false), 'result[4] = 5');
assert((*result.data[5]) == FixedTrait::new_unscaled(2, false), 'result[5] = 2');
assert((*result.data[6]) == FixedTrait::new_unscaled(2, false), 'result[6] = 2');
assert((*result.data[7]) == FixedTrait::new_unscaled(2, false), 'result[7] = 2');
assert((*result.data[8]) == FixedTrait::new_unscaled(5, false), 'result[8] = 5');
assert((*result.data[9]) == FixedTrait::new_unscaled(2, false), 'result[9] = 2');
assert((*result.data[10]) == FixedTrait::new_unscaled(2, false), 'result[10] = 2');
assert((*result.data[11]) == FixedTrait::new_unscaled(2, false), 'result[11] = 2');
assert((*result.data[12]) == FixedTrait::new_unscaled(2, false), 'result[12] = 2');
assert((*result.data[13]) == FixedTrait::new_unscaled(5, false), 'result[13] = 5');
assert((*result.data[14]) == FixedTrait::new_unscaled(2, false), 'result[14] = 2');
assert((*result.data[17]) == FixedTrait::new_unscaled(5, false), 'result[17] = 5');
assert((*result.data[21]) == FixedTrait::new_unscaled(5, false), 'result[21] = 5');
assert((*result.data[26]) == FixedTrait::new_unscaled(5, false), 'result[26] = 5');
assert((*result.data[30]) == FixedTrait::new_unscaled(5, |
false), 'result[30] = 5');
assert((*result.data[34]) == FixedTrait::new_unscaled(5, false), 'result[34] = 5');
assert((*result.data[39]) == FixedTrait::new_unscaled(5, false), 'result[39] = 5');
assert((*result.data[43]) == FixedTrait::new_unscaled(5, false), 'result[43] = 5');
assert((*result.data[46]) == FixedTrait::new_unscaled(2, false), 'result[46] = 2');
assert((*result.data[47]) == FixedTrait::new_unscaled(5, false), 'result[47] = 5');
assert((*result.shape.at(0)) == 4, 'shape[0] = 4');
assert((*result.shape.at(1)) == 3, 'shape[1] = 3');
assert((*result.shape.at(2)) == 2, 'shape[2] = 3');
assert((*result.shape.at(3)) == 2, 'shape[0] = 2');
} |
fn fp_tensor_onehot_3x2x2_new_second_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(1);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.data[16]) == FixedTrait::new_unscaled(1, false), 'result[16] = 1');
assert((*result.data[21]) == FixedTrait::new_unscaled(1, false), 'result[21] = 1');
assert((*result.data[26]) == FixedTrait::new_unscaled(1, |
false), 'result[26] = 1');
assert((*result.data[31]) == FixedTrait::new_unscaled(1, false), 'result[31] = 1');
assert((*result.data[32]) == FixedTrait::new_unscaled(1, false), 'result[32] = 1');
assert((*result.data[37]) == FixedTrait::new_unscaled(1, false), 'result[37] = 1');
assert((*result.data[42]) == FixedTrait::new_unscaled(1, false), 'result[42] = 1');
assert((*result.data[46]) == FixedTrait::new_unscaled(0, false), 'result[46] = 0');
assert((*result.data[47]) == FixedTrait::new_unscaled(1, false), 'result[47] = 1');
assert((*result.shape.at(0)) == 3, 'shape[0] = 3');
assert((*result.shape.at(1)) == 4, 'shape[1] = 4');
assert((*result.shape.at(2)) == 2, 'shape[2] = 3');
assert((*result.shape.at(3)) == 2, 'shape[0] = 2');
} |
fn fp_tensor_onehot_3x2x2_new_third_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(2);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(1, false), 'result[3] = 1');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(1, false), 'result[12] = 1');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.data[16]) == FixedTrait::new_unscaled(1, false), 'result[16] = 1');
assert((*result.data[19]) == FixedTrait::new_unscaled(1, false), 'result[19] = 1');
assert((*result.data[21]) == FixedTrait::new_unscaled(0, false), 'result[21] = 0');
assert((*result.data[26]) == FixedTrait::new_unscaled(0, false), 'result[26] = 0');
assert((*result.data[28]) == FixedTrait::new_unscaled(1, false), 'result[28] = 1');
assert((*result.data[31]) == FixedTrait::new_unscaled(1, false), 'result[31] = 1');
assert((*result.data[32]) == FixedTrait::new_unscaled(1, false), 'result[32] = 1');
assert((*result.data[35]) == FixedTrait::new_unscal |
ed(1, false), 'result[35] = 1');
assert((*result.data[37]) == FixedTrait::new_unscaled(0, false), 'result[37] = 0');
assert((*result.data[44]) == FixedTrait::new_unscaled(1, false), 'result[44] = 1');
assert((*result.data[46]) == FixedTrait::new_unscaled(0, false), 'result[46] = 0');
assert((*result.data[47]) == FixedTrait::new_unscaled(1, false), 'result[47] = 1');
assert((*result.shape.at(0)) == 3, 'shape[0] = 3');
assert((*result.shape.at(1)) == 2, 'shape[1] = 2');
assert((*result.shape.at(2)) == 4, 'shape[2] = 4');
assert((*result.shape.at(3)) == 2, 'shape[0] = 2');
}
} |
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::array::ArrayTrait;
use orion::operators::tensor::core::{ravel_index};
#[test]
#[available_gas(2000000)]
fn tensor_ravel_index() {
let mut shape = ArrayTrait::new();
shape.append(5);
let mut indices = ArrayTrait::new();
indices.append(2);
let result = ravel_index(shape.span(), indices.span());
assert(result == 2, 'result = 2');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::array::ArrayTrait;
use orion::operators::tensor::core::{ravel_index};
#[test]
#[available_gas(2000000)]
fn tensor_ravel_index() {
let mut shape = ArrayTrait::new();
shape.append(2);
shape.append(4);
let mut indices = ArrayTrait::new();
indices.append(1);
indices.append(2);
let result = ravel_index(shape.span(), indices.span());
assert(result == 6, 'result = 6');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::array::ArrayTrait;
use orion::operators::tensor::core::{ravel_index};
#[test]
#[available_gas(2000000)]
fn tensor_ravel_index() {
let mut shape = ArrayTrait::new();
shape.append(2);
shape.append(4);
shape.append(6);
let mut indices = ArrayTrait::new();
indices.append(1);
indices.append(3);
indices.append(0);
let result = ravel_index(shape.span(), indices.span());
assert(result == 42, 'result = 42');
}
}
|
mod stride_u32_test;
mod stride_i32_test;
mod stride_bool_test;
mod stride_fp_test;
|
mod tensor_1D {
use core::array::ArrayTrait;
use orion::operators::tensor::{BoolTensor};
use orion::operators::tensor::core::{TensorTrait}; |
fn tensor_at() {
let mut sizes = ArrayTrait::new();
sizes.append(3);
let mut data = ArrayTrait::new();
data.append(false);
data.append(true);
data.append(false);
let tensor = TensorTrait::<bool>::new(sizes.span(), data.span());
let result = tensor.stride();
assert(*result[0] == 1, 'stride x = 1');
assert(result.len() == 1, 'len = 1');
}
}
mod tensor_2D {
use core::array::ArrayTrait;
use orion::operators::tensor::{BoolTensor};
use orion::operators::tensor::core::{TensorTrait}; |
fn tensor_at() {
let mut sizes = ArrayTrait::new();
sizes.append(2);
sizes.append(2);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(false);
data.append(true);
let tensor = TensorTrait::<bool>::new(sizes.span(), data.span());
let result = tensor.stride();
assert(*result[0] == 2, 'stride x = 2');
assert(*result[1] == 1, 'stride y = 1');
assert(result.len() == 2, 'len = 2');
}
}
mod tensor_3D {
use core::array::ArrayTrait;
use orion::operators::tensor::{BoolTensor};
use orion::operators::tensor::core::{TensorTrait}; |
fn tensor_at() {
let mut sizes = ArrayTrait::new();
sizes.append(2);
sizes.append(2);
sizes.append(2);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
let tensor = TensorTrait::<bool>::new(sizes.span(), data.span());
let result = tensor.stride();
assert(*result[0] == 4, 'stride x = 4');
assert(*result[1] == 2, 'stride y = 2');
assert(*result[2] == 1, 'stride z = 1');
assert(result.len() == 3, 'len = 3');
}
} |
mod stride_fp8x23_test;
mod stride_fp16x16_test;
|
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_stride() {
let tensor = fp_tensor_1x3_helper();
let result = tensor.stride();
assert(*result[0] == 1, 'stride x = 1');
assert(result.len() == 1, 'len = 1');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_stride() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.stride();
assert(*result[0] == 2, 'stride x = 2');
assert(*result[1] == 1, 'stride y = 1');
assert(result.len() == 2, 'len = 2');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_stride() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.stride();
assert(*result[0] == 4, 'stride x = 4');
assert(*result[1] == 2, 'stride y = 2');
assert(*result[2] == 1, 'stride z = 1');
assert(result.len() == 3, 'len = 3');
}
}
|
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_stride() {
let tensor = fp_tensor_1x3_helper();
let result = tensor.stride();
assert(*result[0] == 1, 'stride x = 1');
assert(result.len() == 1, 'len = 1');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_stride() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.stride();
assert(*result[0] == 2, 'stride x = 2');
assert(*result[1] == 1, 'stride y = 1');
assert(result.len() == 2, 'len = 2');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_stride() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.stride();
assert(*result[0] == 4, 'stride x = 4');
assert(*result[1] == 2, 'stride y = 2');
assert(*result[2] == 1, 'stride z = 1');
assert(result.len() == 3, 'len = 3');
}
}
|
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::i32::i32_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_stride() {
let tensor = i32_tensor_1x3_helper();
let result = tensor.stride();
assert(*result[0] == 1, 'stride x = 1');
assert(result.len() == 1, 'len = 1');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::i32::i32_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = i32_tensor_2x2_helper();
let result = tensor.stride();
assert(*result[0] == 2, 'stride x = 2');
assert(*result[1] == 1, 'stride y = 1');
assert(result.len() == 2, 'len = 2');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::i32::i32_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = i32_tensor_2x2x2_helper();
let result = tensor.stride();
assert(*result[0] == 4, 'stride x = 4');
assert(*result[1] == 2, 'stride y = 2');
assert(*result[2] == 1, 'stride z = 1');
assert(result.len() == 3, 'len = 3');
}
}
|
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::u32::u32_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_stride() {
let tensor = u32_tensor_1x3_helper();
let result = tensor.stride();
assert(*result[0] == 1, 'stride x = 1');
assert(result.len() == 1, 'len = 1');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::u32::u32_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = u32_tensor_2x2_helper();
let result = tensor.stride();
assert(*result[0] == 2, 'stride x = 2');
assert(*result[1] == 1, 'stride y = 1');
assert(result.len() == 2, 'len = 2');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::u32::u32_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = u32_tensor_2x2x2_helper();
let result = tensor.stride();
assert(*result[0] == 4, 'stride x = 4');
assert(*result[1] == 2, 'stride y = 2');
assert(*result[2] == 1, 'stride z = 1');
assert(result.len() == 3, 'len = 3');
}
}
|
// ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::core::{unravel_index};
#[test]
#[available_gas(2000000)]
fn tensor_unravel_index() {
let mut shape = ArrayTrait::new();
shape.append(5);
let result = unravel_index(2, shape.span());
assert(*result[0] == 2, 'result[0] = 2');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::core::{unravel_index};
#[test]
#[available_gas(2000000)]
fn tensor_unravel_index() {
let mut shape = ArrayTrait::new();
shape.append(2);
shape.append(4);
let result = unravel_index(6, shape.span());
assert(*result[0] == 1, 'result[0] = 1');
assert(*result[1] == 2, 'result[1] = 2');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use orion::operators::tensor::core::{unravel_index};
#[test]
#[available_gas(2000000)]
fn tensor_unravel_index() {
let mut shape = ArrayTrait::new();
shape.append(2);
shape.append(4);
shape.append(6);
let result = unravel_index(42, shape.span());
assert(*result[0] == 1, 'result[0] = 1');
assert(*result[1] == 3, 'result[1] = 3');
assert(*result[2] == 0, 'result[2] = 0');
}
}
|
import argparse |
import os |
import pprint |
import numpy as np
from addresses |
import ADDRESSES
from dotenv |
import find_dotenv, load_dotenv
from giza_actions.action |
import action
from giza_actions.agent |
import AgentResult, GizaAgent
from giza_actions.task |
import task
from lp_tools |
import get_tick_range
from prefect |
import get_run_logger
from uni_helpers |
import (
approve_token,
check_allowance,
close_position,
get_all_user_positions,
get_mint_params,
)
load_dotenv(find_dotenv())
os.environ["DEV_PASSPHRASE"] = os.environ.get("DEV_PASSPHRASE")
sepolia_rpc_url = os.environ.get("SEPOLIA_RPC_URL")
@task(name="Data processing")
def process_data(realized_vol: float, dec_price_change: float):
pct_change_sq = (100 * dec_price_change) ** 2
X = np.array([[realized_vol, pct_change_sq]])
return X
@task(name="Get volatility and price change data")
def get_data():
realized_vol = 4.20
dec_price_change = 0.1
return realized_vol, dec_price_change
@task(name="Create a Giza agent for the Volatility prediction model")
def create_agent(
model_id: int, version_id: int, chain: str, contracts: dict, account: str
):
"""
Create a Giza agent for the volatility prediction model
"""
agent = GizaAgent(
contracts=contracts,
id=model_id,
version_id=version_id,
chain=chain,
account=account,
)
return agent
@task(name="Run the volatility prediction model")
def predict(agent: GizaAgent, X: np.ndarray):
"""
Predict the next day volatility.
Args:
X (np.ndarray): Input to the model.
Returns:
int: Predicted value.
"""
prediction = agent.predict(input_feed={"val": X}, verifiable=True, job_size="XL")
return prediction
@task(name="Verify the inference proof and return the predicted value")
def get_pred_val(prediction: AgentResult):
"""
Get the value from the prediction.
Args:
prediction (dict): Prediction from the model.
Returns:
int: Predicted value.
"""
return prediction.value[0][0]
@action(log_prints=True)
def rebalance_lp(
tokenA_amount: int,
tokenB_amount: int,
pred_model_id: int,
pred_version_id: int,
account="dev",
chain=f"ethereum:sepolia:{sepolia_rpc_url}",
nft_id=None,
):
logger = get_run_logger()
nft_manager_address = ADDRESSES[" |
NonfungiblePositionManager"][11155111]
tokenA_address = ADDRESSES["UNI"][11155111]
tokenB_address = ADDRESSES["WETH"][11155111]
pool_address = "0x287B0e934ed0439E2a7b1d5F0FC25eA2c24b64f7"
user_address = "0xCBB090699E0664f0F6A4EFbC616f402233718152"
pool_fee = 3000
logger.info("Fetching input data")
realized_vol, dec_price_change = get_data()
logger.info(f"Input data: {realized_vol}, {dec_price_change}")
X = process_data(realized_vol, dec_price_change)
contracts = {
"nft_manager": nft_manager_address,
"tokenA": tokenA_address,
"tokenB": tokenB_address,
"pool": pool_address,
}
agent = create_agent(
model_id=pred_model_id,
version_id=pred_version_id,
chain=chain,
contracts=contracts,
account=account,
)
result = predict(agent, X)
predicted_value = get_pred_val(result)
logger.info(f"Result: {result}")
with agent.execute() as contracts:
logger.info("Executing contract")
if nft_id is None:
positions = [
max(get_all_user_positions(contracts.nft_manager, user_address))
]
else:
positions = [nft_id]
logger.info(f"Closing the following positions {positions}")
for nft_id in positions:
close_position(user_address, contracts.nft_manager, nft_id)
logger.info("Calculating mint params...")
_, curr_tick, _, _, _, _, _ = contracts.pool.slot0()
if not check_allowance(
contracts.tokenA, nft_manager_address, account, tokenA_amount
):
approve_token(contracts.tokenA, nft_manager_address, tokenA_amount)
if not check_allowance(
contracts.tokenB, nft_manager_address, account, tokenB_amount
):
approve_token(contracts.tokenB, nft_manager_address, tokenB_amount)
tokenA_decimals = contracts.tokenA.decimals()
tokenB_decimals = contracts.tokenB.decimals()
predicted_value = predicted_value / |
100 * 1.96
lower_tick, upper_tick = get_tick_range(
curr_tick, predicted_value, tokenA_decimals, tokenB_decimals, pool_fee
)
mint_params = get_mint_params(
user_address,
contracts.tokenA.address,
contracts.tokenB.address,
tokenA_amount,
tokenB_amount,
pool_fee,
lower_tick,
upper_tick,
)
logger.info("Minting new position...")
contract_result = contracts.nft_manager.mint(mint_params)
logger.info("SUCCESSFULLY MINTED A POSITION")
logger.info("Contract executed")
logger.info(f"Contract result: {contract_result}")
pprint.pprint(contract_result.__dict__)
logger.info("Finished")
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--model-id", metavar="M", type=int, help="model-id")
parser.add_argument("--version-id", metavar="V", type=int, help="version-id")
parser.add_argument("--tokenA-amount", metavar="A", type=int, help="tokenA-amount")
parser.add_argument("--tokenB-amount", metavar="B", type=int, help="tokenB-amount")
args = parser.parse_args()
MODEL_ID = args.model_id
VERSION_ID = args.version_id
tokenA_amount = args.tokenA_amount
tokenB_amount = args.tokenB_amount
rebalance_lp(tokenA_amount, tokenB_amount, MODEL_ID, VERSION_ID) |
# source: https://docs.uniswap.org/contracts/v3/reference/deployments
ADDRESSES = {
"WETH": {
1: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
11155111: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
5: "0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6",
42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
},
"UNI": {
1: "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984",
11155111: "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984",
5: "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984",
42161: "0xFa7F8980b0f1E64A2062791cc3b0871572f1F7f0",
},
"USDC": {
1: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
11155111: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
5: "",
42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
},
"NonfungiblePositionManager": {
1: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
11155111: "0x1238536071E1c677A632429e3655c799b22cDA52",
5: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
42161: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
},
"PoolFactory": {
1: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
11155111: "0x0227628f3F023bb0B980b67D528571c95c6DaC1c",
5: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
42161: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
},
"Router": {
1: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
11155111: "0x3bFA4769FB09eefC5a80d6E87c3B9C650f7Ae48E",
5: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
42161: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
},
}
|
import os
from addresses import ADDRESSES
from ape import Contract, accounts, chain, networks
from dotenv import find_dotenv, load_dotenv
load_dotenv(find_dotenv())
dev_passphrase = os.environ.get("DEV_PASSPHRASE")
sepolia_rpc_url = os.environ.get("SEPOLIA_RPC_URL")
if __name__ == "__main__":
networks.parse_network_choice(f"ethereum:sepolia:{sepolia_rpc_url}").__enter__()
chain_id = chain.chain_id
weth_mint_amount = 0.0001
pool_fee = 3000
uni = Contract(ADDRESSES["UNI"][chain_id])
weth = Contract(ADDRESSES["WETH"][chain_id])
weth_decimals = weth.decimals()
uni_decimals = uni.decimals()
weth_mint_amount = int(weth_mint_amount * 10**weth_decimals)
uni_mint_amount = int(0.5 * weth_mint_amount)
pool_factory = Contract(ADDRESSES["PoolFactory"][chain_id])
pool_address = "0x287B0e934ed0439E2a7b1d5F0FC25eA2c24b64f7"
pool = Contract(pool_address)
swap_router = Contract(ADDRESSES["Router"][chain_id])
wallet = accounts.load("dev")
wallet.set_autosign(True, passphrase=dev_passphrase)
with accounts.use_sender("dev"):
print(f"Minting {weth_mint_amount/10**weth_decimals} WETH")
weth.deposit(value=weth_mint_amount)
print("Approving WETH for swap")
weth.approve(swap_router.address, weth_mint_amount)
swap_params = {
"tokenIn": weth.address,
"tokenOut": uni.address,
"fee": pool_fee,
"recipient": wallet.address,
"amountIn": weth_mint_amount,
"amountOutMinimum": 0,
"sqrtPriceLimitX96": 0,
}
swap_params = tuple(swap_params.values())
print("Swapping WETH for UNI")
amountOut = swap_router.exactInputSingle(swap_params)
print(f"Successfully minted {uni_mint_amount/10**uni_decimals} UNI")
print(f"Your WETH balance: {weth.balanceOf(wallet.address)/10**weth_decimals}")
print(f"Your UNI balance: {uni.balanceOf(wallet.address)/10**uni_decimals}")
|
import math
MIN_TICK = -887272
MAX_TICK = -MIN_TICK
TICKS_Q = 1.0001
Q96 = 2**96
MAX_UINT_128 = 2 ** (128) - 1
_tick_spacing = {100: 1, 500: 10, 3_000: 60, 10_000: 200}
def price_to_tick(price):
sqrtPriceX96 = int(price * 2**96)
tick = math.floor(math.log((sqrtPriceX96 / Q96) ** 2) / math.log(TICKS_Q))
return tick
def tick_to_price(tick, decimals0, decimals1, invert=False):
if invert:
return 1 / (TICKS_Q**tick / 10 ** (decimals1 - decimals0))
else:
return TICKS_Q**tick / 10 ** (decimals1 - decimals0)
def get_min_tick(fee: int):
min_tick_spacing: int = _tick_spacing[fee]
return -(MIN_TICK
def get_max_tick(fee: int):
max_tick_spacing: int = _tick_spacing[fee]
return (MAX_TICK
def default_tick_range(fee: int):
min_tick = get_min_tick(fee)
max_tick = get_max_tick(fee)
return min_tick, max_tick
def nearest_tick(tick: int, fee: int):
min_tick, max_tick = default_tick_range(fee)
assert (
min_tick <= tick <= max_tick
), f"Provided tick is out of bounds: {(min_tick, max_tick)}"
tick_spacing = _tick_spacing[fee]
rounded_tick_spacing = round(tick / tick_spacing) * tick_spacing
if rounded_tick_spacing < min_tick:
return rounded_tick_spacing + tick_spacing
elif rounded_tick_spacing > max_tick:
return rounded_tick_spacing - tick_spacing
else:
return rounded_tick_spacing
def get_tick_range(curr_tick, pct_dev, tokenA_decimals, tokenB_decimals, fee):
curr_price = tick_to_price(curr_tick, tokenA_decimals, tokenB_decimals)
upper_price = curr_price * (1 + pct_dev)
lower_price = curr_price * (1 - pct_dev)
lower_tick = price_to_tick(lower_price)
upper_tick = price_to_tick(upper_price)
lower_tick = nearest_tick(lower_tick, fee)
upper_tick = nearest_tick(upper_tick, fee)
return lower_tick, upper_tick |
import datetime |
import numpy as np |
import pandas as pd |
import torch |
import torch.nn as nn |
import torch.optim as optim |
import yfinance as yf
from sklearn.metrics |
import mean_squared_error as mse
def download_data():
uni_ticker = "UNI-USD"
eth_ticker = "ETH-USD"
start = datetime.datetime(2019, 1, 1)
end = datetime.datetime(2024, 4, 1)
uni = yf.download(uni_ticker, start=start, end=end, interval="1d")
eth = yf.download(eth_ticker, start=start, end=end, interval="1d")
uni = uni.reset_index()
uni.to_csv("uni.csv", index=False)
eth = eth.reset_index()
eth.to_csv("eth.csv", index=False)
return uni, eth
def process_data(uni: pd.DataFrame, eth: pd.DataFrame):
uni = uni[uni["Open"] < 0.30]
uni = uni[["Date", "Open"]]
eth = eth[["Date", "Open"]]
uni.rename(columns={"Open": "UNI"}, inplace=True)
eth.rename(columns={"Open": "ETH"}, inplace=True)
df = pd.merge(uni, eth, on="Date")
df.dropna(inplace=True)
df["price"] = df["ETH"] / df["UNI"]
ret = 100 * (df["price"].pct_change()[1:])
realized_vol = ret.rolling(5).std()
realized_vol = pd.DataFrame(realized_vol)
realized_vol.reset_index(drop=True, inplace=True)
returns_svm = ret**2
returns_svm = returns_svm.reset_index()
X = pd.concat([realized_vol, returns_svm], axis=1, ignore_index=True)
X = X[4:].copy()
X = X.reset_index()
X.drop("index", axis=1, inplace=True)
X.drop(1, axis=1, inplace=True)
X.rename(columns={0: "realized_vol", 2: "returns_squared"}, inplace=True)
X["target"] = X["realized_vol"].shift(-5)
X.dropna(inplace=True)
Y = X["target"]
X.drop("target", axis=1, inplace=True)
n = 252
X_train = X.iloc[:-n]
X_test = X.iloc[-n:]
Y_train = Y.iloc[:-n]
Y_test = Y.iloc[-n:]
return X_train, X_test, Y_train, Y_test
def train_model(
X_train: pd.DataFrame,
X_test: pd.DataFrame,
Y_train: pd.DataFrame,
Y_test: pd.DataFrame,
):
model = nn.Sequential(
nn.Linear(X_train.shape[1], 128),
nn.ReLU(),
nn.Linear(128, 64),
nn.ReLU(),
nn.Linear(64, 1),
)
criterion = nn.MSELoss()
optimizer = optim.RMSprop( |
model.parameters())
X_tensor = torch.tensor(X_train.values, dtype=torch.float32)
y_tensor = torch.tensor(Y_train.values.reshape(-1, 1), dtype=torch.float32)
X_test_tensor = torch.tensor(X_test.values, dtype=torch.float32)
epochs_trial = np.arange(100, 400, 4)
batch_trial = np.arange(100, 400, 4)
DL_pred = []
DL_RMSE = []
for i, j, k in zip(range(4), epochs_trial, batch_trial):
for epoch in range(j):
optimizer.zero_grad()
outputs = model(X_tensor)
loss = criterion(outputs, y_tensor)
loss.backward()
optimizer.step()
with torch.no_grad():
DL_predict = model(X_test_tensor).numpy()
DL_RMSE.append(
np.sqrt(mse(Y_test.values / 100, DL_predict.flatten() / 100))
)
DL_pred.append(DL_predict)
print("DL_RMSE_{}:{:.6f}".format(i + 1, DL_RMSE[i]))
return model
def serialize_to_onnx(
model: nn.Module, X_train: pd.DataFrame, save_path="torch_vol_model"
):
model.eval()
sample_input = torch.randn(
1, X_train.shape[1]
)
onnx_file_path = save_path + ".onnx"
torch.onnx.export(
model,
sample_input,
onnx_file_path,
export_params=True,
opset_version=10,
do_constant_folding=True,
input_names=["input"],
output_names=["output"],
dynamic_axes={
"input": {0: "batch_size"},
"output": {0: "batch_size"},
},
)
print(f"Saved serialized ONNX model to {onnx_file_path}.")
def main():
uni, eth = download_data()
X_train, X_test, Y_train, Y_test = process_data(uni, eth)
model = train_model(X_train, X_test, Y_train, Y_test)
serialize_to_onnx(model, X_train)
if __name__ == "__main__":
main() |
import os |
import time
from ape.contracts.base |
import ContractInstance
from dotenv |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.