file_path
stringlengths 7
180
| content
stringlengths 0
811k
| repo
stringclasses 11
values |
|---|---|---|
docgen/src/main.rs | use regex::Regex;
use std::fs;
use std::path::Path;
fn main() {
// TENSOR DOC
let trait_path = "src/operators/tensor/core.cairo";
let doc_path = "docs/framework/operators/tensor";
let label = "tensor";
let trait_name = "TensorTrait";
doc_trait(trait_path, doc_path, label);
doc_functions(trait_path, doc_path, trait_name, label);
// NN DOC
let trait_path = "src/operators/nn/core.cairo";
let doc_path = "docs/framework/operators/neural-network";
let label = "nn";
let trait_name = "NNTrait";
doc_trait(trait_path, doc_path, label);
doc_functions(trait_path, doc_path, trait_name, label);
// SEQUENCE DOC
let trait_path = "src/operators/sequence/core.cairo";
let doc_path = "docs/framework/operators/sequence";
let label = "sequence";
let trait_name = "SequenceTrait";
doc_trait(trait_path, doc_path, label);
doc_functions(trait_path, doc_path, trait_name, label);
// FIXED POINT DOC
let trait_path = "src/numbers/fixed_point/core.cairo";
let doc_path = "docs/framework/numbers/fixed-point";
let label = "fp";
let trait_name = "FixedTrait";
doc_trait(trait_path, doc_path, label);
doc_functions(trait_path, doc_path, trait_name, label);
// COMPLEX NUMBER DOC
let trait_path = "src/numbers/complex_number/complex_trait.cairo";
let doc_path = "docs/framework/numbers/complex-number";
let label = "complex";
let trait_name: &str = "ComplexTrait";
doc_trait(trait_path, doc_path, label);
doc_functions(trait_path, doc_path, trait_name, label);
// TREE ENSEMBLE CLASSIFIER DOC
let trait_path = "src/operators/ml/tree_ensemble/tree_ensemble_classifier.cairo";
let doc_path = "docs/framework/operators/machine-learning/tree-ensemble-classifier";
let label = "tree_ensemble_classifier";
let trait_name: &str = "TreeEnsembleClassifierTrait";
doc_trait(trait_path, doc_path, label);
doc_functions(trait_path, doc_path, trait_name, label);
// TREE ENSEMBLE REGRESSOR DOC
let trait_path = "src/operators/ml/tree_ensemble/tree_ensemble_regressor.cairo";
let doc_path = "docs/framework/operators/machine-learning/tree-ensemble-regressor";
let label = "tree_ensemble_regressor";
let trait_name: &str = "TreeEnsembleRegressorTrait";
doc_trait(trait_path, doc_path, label);
doc_functions(trait_path, doc_path, trait_name, label);
// LINEAR REGRESSOR DOC
let trait_path = "src/operators/ml/linear/linear_regressor.cairo";
let doc_path = "docs/framework/operators/machine-learning/linear-regressor";
let label = "linear_regressor";
let trait_name: &str = "LinearRegressorTrait";
doc_trait(trait_path, doc_path, label);
doc_functions(trait_path, doc_path, trait_name, label);
// LINEAR CLASSIFIER DOC
let trait_path = "src/operators/ml/linear/linear_classifier.cairo";
let doc_path = "docs/framework/operators/machine-learning/linear-classifier";
let label = "linear_classifier";
let trait_name: &str = "LinearClassifierTrait";
doc_trait(trait_path, doc_path, label);
doc_functions(trait_path, doc_path, trait_name, label);
// SVM REGRESSOR DOC
let trait_path = "src/operators/ml/svm/svm_regressor.cairo";
let doc_path = "docs/framework/operators/machine-learning/svm-regressor";
let label = "svm_regressor";
let trait_name: &str = "SVMRegressorTrait";
doc_trait(trait_path, doc_path, label);
doc_functions(trait_path, doc_path, trait_name, label);
// SVM CLASSIFIER DOC
let trait_path = "src/operators/ml/svm/svm_classifier.cairo";
let doc_path = "docs/framework/operators/machine-learning/svm-classifier";
let label = "svm_classifier";
let trait_name: &str = "SVMClassifierTrait";
doc_trait(trait_path, doc_path, label);
doc_functions(trait_path, doc_path, trait_name, label);
// NORMALIZER DOC
let trait_path = "src/operators/ml/normalizer/normalizer.cairo";
let doc_path = "docs/framework/operators/machine-learning/normalizer";
let label = "normalizer";
let trait_name: &str = "NormalizerTrait";
doc_trait(trait_path, doc_path, label);
doc_functions(trait_path, doc_path, trait_name, label);
}
fn doc_trait(trait_path: &str, doc_path: &str, label: &str) {
// Open and read core.cairo file
let path_str = format!("../{}", trait_path);
let path = Path::new(&path_str);
let contents = fs::read_to_string(&path).expect("Could not read the file");
// Create a regular expression to match the comment lines
let re = Regex::new(r#"/// (\w+) - (.*)"#).unwrap();
// Initialize an empty string to store our new formatted table
let mut table = String::from("| function | description |\n| --- | --- |\n");
// Go through the file and look for comments with our specific format
for cap in re.captures_iter(&contents) {
// Check if the function is the Trait definition and skip it
if &cap[1] == "Trait" {
continue;
}
// Add the function name and description to our table
let func_name = format!(
"[`{}.{}`]({}.{}.md)",
label,
&cap[1],
label,
&cap[1].replace('_', r"\_")
);
let func_desc = &cap[2];
table += &format!("| {} | {} |\n", func_name, func_desc);
}
// Open the README.md file
let readme_path_str = format!("../{}/README.md", doc_path);
let readme_path = Path::new(&readme_path_str);
let readme = fs::read_to_string(&readme_path).expect("Could not read the file");
// Use regex to replace the table
let re_table = Regex::new(r"(?ms)\n\n\| fun.*?(\n[^|]|\z)").unwrap();
let new_readme = re_table.replace(&readme, &("\n\n".to_owned() + &table + "\n"));
// Write the updated contents back to README.md
fs::write(&readme_path, &*new_readme).expect("Could not write the file");
}
fn doc_functions(trait_path: &str, doc_path: &str, trait_name: &str, label: &str) {
let filepath_str = format!("../{}", trait_path);
let filepath = Path::new(&filepath_str);
let contents = fs::read_to_string(filepath).expect("Something went wrong reading the file");
// Find the trait block
let trait_re = Regex::new(&format!(
r"(?s)trait\s+{}\s*(<[\w\s,]*>)?\s*\{{.*?\n\s*\}}",
trait_name
))
.unwrap();
let trait_match = trait_re.captures(&contents).unwrap();
let trait_block = trait_match.get(0).unwrap().as_str();
// Iterate over each function
let func_re = Regex::new(r"(?s)(///.*?\n)\s*fn (\w+)\((.*?)\) -> (.*?);").unwrap();
for func_match in func_re.captures_iter(trait_block) {
let func_name = func_match.get(2).unwrap().as_str();
let doc_comment = func_match.get(1).unwrap().as_str();
// Go to the appropriate markdown file and write the transformed doc comment
let markdown_filename = format!("../{}/{}.{}.md", doc_path, label, func_name);
let transformed_comment = doc_comment
.lines()
.map(|line| {
line.trim_start().strip_prefix("/// ").unwrap_or(
line.trim_start()
.strip_prefix("///")
.unwrap_or(line.trim_start()),
)
})
.collect::<Vec<_>>()
.join("\n");
// Write or replace the transformed comment into the markdown file
fs::write(markdown_filename, transformed_comment).expect("Unable to write file");
}
}
| https://github.com/gizatechxyz/orion |
nodegen/__init__.py | https://github.com/gizatechxyz/orion |
|
nodegen/file_manager.py | import os
from pathlib import Path
BASE_PATH = "./tests/nodes"
class ModFile:
def __init__(self):
"""
Initialize a ModFile object.
This method creates a new file with a .cairo extension in the BASE_PATH directory.
If the directory doesn't exist, it's created. The contents of the file are then read
into the buffer attribute.
"""
self.path = Path(f"{BASE_PATH}.cairo")
self.path.parent.mkdir(parents=True, exist_ok=True)
with self.path.open("r") as f:
self.buffer = f.readlines()
def update(self, name: str):
"""
Update the .cairo file with a new module statement.
Args:
name (str): The name of the module to be added.
This method checks if a module statement for the given name already exists in the buffer.
If it doesn't, the new module statement is appended to the file.
"""
statement = f"mod {name};"
if any([line.startswith(statement) for line in self.buffer]):
return
with self.path.open("a") as f:
f.write(f"{statement}\n")
class File:
def __init__(self, path: str):
"""
Initialize a File object.
Args:
path (str): The file path where the File object will operate.
This method creates a new file at the specified path. If the file already exists, its
contents are read into the buffer attribute.
"""
self.path = Path(path)
self.path.parent.mkdir(parents=True, exist_ok=True)
self.buffer = []
if os.path.isfile(path):
with self.path.open("r") as f:
self.buffer = f.readlines()
def dump(self):
"""
Write the contents of the buffer to the file.
This method writes each line in the buffer to the file, ensuring each line is
properly terminated with a newline character.
"""
with self.path.open("w") as f:
f.writelines([f"{line}\n" for line in self.buffer])
class CairoTest(File):
def __init__(self, file: str):
super().__init__(os.path.join(BASE_PATH, file))
@classmethod
def base_template(
cls, name: str, arg_cnt: int, refs: list[str], func_sig: str, out_cnt: int = 1
) -> list[str]:
"""
Create a template for a Cairo test function which expects a tensor output.
Args:
name (str): Name of the test function.
arg_cnt (int): Number of arguments for the function.
refs (list[str]): List of references (modules) to be used in the function.
func_sig (str): The function signature.
out_cnt (int): Number of outputs for the function. Defaults to 1.
Returns:
list[str]: A list of strings that together form the template of a Cairo test function.
This method generates a list of strings that form the template of a Cairo test function,
including module imports, function definition, and assertions.
"""
template = [
*[f"mod input_{i};" for i in range(arg_cnt)],
*[f"mod output_{i};" for i in range(out_cnt)],
"",
"",
*[f"use {ref};" for ref in refs],
"",
"#[test]",
"#[available_gas(2000000000)]",
f"fn test_{name}()" + " {",
*[f" let input_{i} = input_{i}::input_{i}();" for i in range(arg_cnt)],
*[f" let z_{i} = output_{i}::output_{i}();" for i in range(out_cnt)],
""
]
# Handling conditional function signature based on the number of outputs
if out_cnt > 1:
template.append(f" let ({', '.join(f'y_{i}' for i in range(out_cnt))}) = {func_sig};")
else:
template.append(f" let y_0 = {func_sig};")
# Continue appending to the template
template.extend([
"",
*[f" assert_eq(y_{i}, z_{i});" for i in range(out_cnt)],
"}"
])
return template
@classmethod
def sequence_template(cls, name: str, arg_cnt: int, refs: list[str], func_sig: str) -> list[str]:
"""
Create a template for a Cairo test function which expects a tensor sequence.
Args:
name (str): Name of the test function.
arg_cnt (int): Number of arguments for the function.
refs (list[str]): List of references (modules) to be used in the function.
func_sig (str): The function signature.
Returns:
list[str]: A list of strings that together form the template of a Cairo test function.
This method generates a list of strings that form the template of a Cairo test function,
including module imports, function definition, and assertions.
"""
return [
*[f"mod input_{i};" for i in range(arg_cnt)],
*[ "mod output_0;"],
*[ ""],
*[ ""],
*[f"use {ref};" for ref in refs],
*[ ""],
*[ "#[test]"],
*[ "#[available_gas(2000000000)]"],
*[f"fn test_{name}()"+" {"],
*[f" let input_{i} = input_{i}::input_{i}();" for i in range(arg_cnt)],
*[ " let z = output_0::output_0();"],
*[ ""],
*[f" let y = {func_sig};"],
*[ ""],
*[ " assert_seq_eq(y, z);"],
*[ "}"],
]
class CairoData(File):
def __init__(self, file: str):
super().__init__(os.path.join(BASE_PATH, file))
@classmethod
def base_template(
cls, func: str, dtype: str, refs: list[str], data: list[str], shape: tuple
) -> list[str]:
"""
Create a base template for data representation in Cairo.
Args:
func (str): The function name.
dtype (str): The data type of the tensor.
refs (list[str]): A list of module references.
data (list[str]): The data to be included in the tensor.
shape (tuple): The shape of the tensor.
Returns:
list[str]: A list of strings that together form the template of a data function in Cairo.
This method generates a list of strings representing a function in Cairo for data handling,
defining the shape and contents of a tensor.
"""
template = [
*[f"use {ref};" for ref in refs],
*[""],
*[f"fn {func}() -> Tensor<{dtype}>" + " {"],
*[" let mut shape = ArrayTrait::<usize>::new();"],
*[f" shape.append({s});" for s in shape],
*[""],
*[" let mut data = ArrayTrait::new();"],
*[f" data.append({d});" for d in data],
*[" TensorTrait::new(shape.span(), data.span())"],
*["}"],
]
return template
@classmethod
def sequence_template(
cls,
func: str,
dtype: str,
refs: list[str],
data: list[list[str]],
shape: list[tuple],
) -> list[str]:
"""
Create a template for handling tensor sequences in Cairo.
Args:
func (str): The function name.
dtype (str): The data type of the tensor sequence.
refs (list[str]): A list of module references.
data (list[list[str]]): The data to be included in each tensor.
shape (list[tuple]): The shapes of each tensor in the sequence.
Returns:
list[str]: A list of strings that together form the template of a sequence tensor function in Cairo.
This method generates a list of strings representing a function in Cairo for handling a sequence
of tensors, each with its own data and shape.
"""
def expand_sequence_init(s: list[tuple], d: list[list[str]]) -> list[str]:
snippet = []
for i in range(len(s)):
snippet += [
*[" let mut shape = ArrayTrait::<usize>::new();"],
*[f" shape.append({s});" for s in s[i]],
*[""],
*[" let mut data = ArrayTrait::new();"],
*[f" data.append({d});" for d in d[i]],
*[""],
*[
" sequence.append(TensorTrait::new(shape.span(), data.span()));"
],
*[""],
]
return snippet
template = [
*[f"use {ref};" for ref in refs],
*[""],
*[f"fn {func}() -> Array<Tensor<{dtype}>>" + " {"],
*[" let mut sequence = ArrayTrait::new();"],
*[""],
*expand_sequence_init(shape, data),
*[" sequence"],
*["}"],
]
return template | https://github.com/gizatechxyz/orion |
nodegen/helpers.py | from enum import Enum
import os
from typing import List
from .file_manager import CairoTest, CairoData, ModFile
import numpy as np
class FixedImpl(Enum):
FP8x23 = 'FP8x23'
FP16x16 = 'FP16x16'
FP32x32 = 'FP32x32'
def to_fp(x: np.ndarray, fp_impl: FixedImpl):
match fp_impl:
case FixedImpl.FP8x23:
return (x * 2**23).astype(np.int64)
case FixedImpl.FP16x16:
return (x * 2**16).astype(np.int64)
case FixedImpl.FP32x32:
return (x * 2**32).astype(np.int64)
class Dtype(Enum):
FP8x23 = 'FP8x23'
FP16x16 = 'FP16x16'
FP32x32 = 'FP32x32'
I8 = 'i8'
I32 = 'i32'
U32 = 'u32'
BOOL = 'bool'
COMPLEX64 = 'complex64'
class Tensor:
def __init__(self, dtype: Dtype, shape: tuple, data: np.ndarray):
self.dtype = dtype
self.shape = shape
self.data = data
Sequence = List[Tensor]
class Trait(Enum):
TENSOR = 'TENSOR'
NN = 'NN'
SEQUENCE = 'SEQUENCE'
def make_test(inputs: list[Tensor | Sequence], output: Tensor | Sequence, func_sig: str, name: str, trait: Trait = Trait.TENSOR):
"""
Generate and write Cairo tests based on the provided inputs and output.
Args:
inputs (list[Tensor | list[Tensor]]): A list of input tensors or tensor sequences.
output (Tensor | list[Tensor]): The expected output tensor or tensor sequences.
func_sig (str): The signature of the function to be tested.
name (str): The name of the test.
trait (Trait, optional): The trait of the tensors. Defaults to Trait.TENSOR.
"""
ModFile().update(name)
for i, input in enumerate(inputs):
input_data = CairoData(os.path.join(name, f"input_{i}.cairo"))
match input:
case list():
input_data.buffer = CairoData.sequence_template(
func=f"input_{i}",
dtype=input[0].dtype.value,
refs=get_data_refs(input[0].dtype),
data=get_data_statement_for_sequences(
input, input[0].dtype),
shape=[x.shape for x in input],
)
case Tensor():
input_data.buffer = CairoData.base_template(
func=f"input_{i}",
dtype=input.dtype.value,
refs=get_data_refs(input.dtype),
data=get_data_statement(input.data, input.dtype),
shape=input.shape,
)
input_data.dump()
match output:
case list():
output_data = CairoData(os.path.join(name, "output_0.cairo"))
output_data.buffer = CairoData.sequence_template(
func="output_0",
dtype=output[0].dtype.value,
refs=get_data_refs(output[0].dtype),
data=get_data_statement_for_sequences(output, output[0].dtype),
shape=[x.shape for x in output],
)
output_data.dump()
case tuple():
for i, out in enumerate(output):
output_data = CairoData(
os.path.join(name, f"output_{i}.cairo"))
output_data.buffer = CairoData.base_template(
func=f"output_{i}",
dtype=out.dtype.value,
refs=get_data_refs(out.dtype),
data=get_data_statement(out.data, out.dtype),
shape=out.shape,
)
output_data.dump()
case Tensor():
output_data = CairoData(os.path.join(name, "output_0.cairo"))
output_data.buffer = CairoData.base_template(
func="output_0",
dtype=output.dtype.value,
refs=get_data_refs(output.dtype),
data=get_data_statement(output.data, output.dtype),
shape=output.shape,
)
output_data.dump()
test_file = CairoTest(f"{name}.cairo")
match output:
case list():
test_file.buffer = CairoTest.sequence_template(
name=name,
arg_cnt=len(inputs),
refs=get_all_test_refs(find_all_types([*inputs, *output]), trait),
func_sig=func_sig,
)
case Tensor():
test_file.buffer = CairoTest.base_template(
name=name,
arg_cnt=len(inputs),
refs=get_all_test_refs(find_all_types([*inputs, output]), trait),
func_sig=func_sig,
)
case tuple():
test_file.buffer = CairoTest.base_template(
name=name,
arg_cnt=len(inputs),
out_cnt=len(output),
refs=get_all_test_refs(find_all_types([*inputs, output]), trait),
func_sig=func_sig,
)
test_file.dump()
def get_data_refs(dtype: Dtype) -> list[str]:
refs = [
*trait_to_ref[Trait.TENSOR],
*dtype_to_tensor[dtype],
*dtype_to_numbers[dtype],
]
return refs
def get_data_statement(data: np.ndarray, dtype: Dtype) -> list[str]:
match dtype:
case Dtype.U32:
return [f"{int(x)}" for x in data.flatten()]
case Dtype.I32:
return [f"{int(x)}" for x in data.flatten()]
case Dtype.I8:
return [f"{int(x)}" for x in data.flatten()]
case Dtype.FP8x23:
return ["FP8x23 { "+f"mag: {abs(int(x))}, sign: {str(x < 0).lower()} "+"}" for x in data.flatten()]
case Dtype.FP16x16:
return ["FP16x16 { "+f"mag: {abs(int(x))}, sign: {str(x < 0).lower()} "+"}" for x in data.flatten()]
case Dtype.FP32x32:
return ["FP32x32 { "+f"mag: {abs(int(x))}, sign: {str(x < 0).lower()} "+"}" for x in data.flatten()]
case Dtype.BOOL:
return [str(x).lower() for x in data.flatten()]
case Dtype.COMPLEX64:
return ["complex64 { "+"real: FP64x64 { "+f"mag: {abs(int(np.real(x)))}, sign: {str(np.real(x) < 0).lower()} "+"} , img: FP64x64 { "+f"mag: {abs(int(np.imag(x)))}, sign: {str(np.imag(x) < 0).lower()} "+"} }" for x in data.flatten()]
def get_data_statement_for_sequences(data: Sequence, dtype: Dtype) -> list[list[str]]:
return [get_data_statement(x.data, dtype) for x in data]
def get_all_test_refs(dtypes: list[Dtype], trait: Trait) -> list[str]:
refs = []
for dtype in dtypes:
# refs += [*dtype_to_numbers[dtype]]
refs += get_test_refs(dtype, trait)
return list(set(refs))
def get_test_refs(dtype: Dtype, trait: Trait) -> list[str]:
if trait == Trait.NN and dtype == Dtype.BOOL:
raise Exception("NN trait does not support bool dtype")
if trait == Trait.NN:
dtype_ref = dtype_to_nn[dtype]
elif trait == Trait.SEQUENCE:
dtype_ref = dtype_to_sequence[dtype]
else:
dtype_ref = dtype_to_tensor[dtype]
refs = [
*trait_to_ref[trait],
*dtype_ref,
*dtype_to_partial_eq[dtype],
"orion::utils::{assert_eq, assert_seq_eq}",
]
return refs
def find_all_types(tensors: list[Tensor | Sequence]) -> list[Dtype]:
dtypes = []
for tensor in tensors:
if isinstance(tensor, list) or isinstance(tensor, tuple):
dtypes += [x.dtype for x in tensor]
else:
dtypes.append(tensor.dtype)
return list(set(dtypes))
trait_to_ref = {
Trait.TENSOR: [
"core::array::{ArrayTrait, SpanTrait}",
"orion::operators::tensor::{TensorTrait, Tensor}",
],
Trait.NN: [
"orion::numbers::FixedTrait",
"orion::operators::nn::NNTrait",
],
Trait.SEQUENCE: [
"core::array::{ArrayTrait, SpanTrait}",
"orion::operators::sequence::SequenceTrait",
],
}
dtype_to_tensor = {
Dtype.U32: ["orion::operators::tensor::{U32Tensor, U32TensorAdd}",],
Dtype.I32: ["orion::operators::tensor::{I32Tensor, I32TensorAdd}",],
Dtype.I8: ["orion::operators::tensor::{I8Tensor, I8TensorAdd}",],
Dtype.FP8x23: ["orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd}",],
Dtype.FP16x16: ["orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd}",],
Dtype.BOOL: ["orion::operators::tensor::BoolTensor",],
Dtype.COMPLEX64: ["orion::operators::tensor::Complex64Tensor",],
Dtype.FP32x32: ["orion::operators::tensor::FP32x32Tensor",],
}
dtype_to_nn = {
Dtype.U32: ["orion::operators::nn::U32NN",],
Dtype.I32: ["orion::operators::nn::I32NN",],
Dtype.I8: ["orion::operators::nn::I8NN",],
Dtype.FP8x23: ["orion::operators::nn::FP8x23NN",],
Dtype.FP16x16: ["orion::operators::nn::FP16x16NN",],
}
dtype_to_sequence = {
Dtype.U32: ["orion::operators::sequence::U32Sequence",],
Dtype.I32: ["orion::operators::sequence::I32Sequence",],
Dtype.I8: ["orion::operators::sequence::I8Sequence",],
Dtype.FP8x23: ["orion::operators::sequence::FP8x23Sequence",],
Dtype.FP16x16: ["orion::operators::sequence::FP16x16Sequence",],
}
dtype_to_partial_eq = {
Dtype.U32: ["orion::operators::tensor::U32TensorPartialEq",],
Dtype.I32: ["orion::operators::tensor::I32TensorPartialEq",],
Dtype.I8: ["orion::operators::tensor::I8TensorPartialEq",],
Dtype.FP8x23: ["orion::operators::tensor::FP8x23TensorPartialEq",],
Dtype.FP16x16: ["orion::operators::tensor::FP16x16TensorPartialEq",],
Dtype.FP32x32: ["orion::operators::tensor::FP32x32TensorPartialEq",],
Dtype.BOOL: ["orion::operators::tensor::BoolTensorPartialEq",],
Dtype.COMPLEX64: ["orion::operators::tensor::Complex64TensorPartialEq",],
}
dtype_to_numbers = {
Dtype.U32: ["orion::numbers::NumberTrait"],
Dtype.I32: ["orion::numbers::NumberTrait"],
Dtype.I8: ["orion::numbers::NumberTrait"],
Dtype.FP8x23: ["orion::numbers::{FixedTrait, FP8x23}",],
Dtype.FP16x16: ["orion::numbers::{FixedTrait, FP16x16}",],
Dtype.FP32x32: ["orion::numbers::{FixedTrait, FP32x32}",],
Dtype.BOOL: [],
Dtype.COMPLEX64: ["orion::numbers::{NumberTrait, complex64}",],
} | https://github.com/gizatechxyz/orion |
nodegen/node/__init__.py | import argparse
import importlib
import os
import sys
class RunAll:
@classmethod
def run_all(cls):
for method_name in dir(cls):
if method_name.startswith('__') or method_name == 'run_all':
continue
method = getattr(cls, method_name)
if callable(method):
method()
# Add the path to the 'orion' directory to the Python path
sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
def main():
parser = argparse.ArgumentParser(description="Generate nodes.")
parser.add_argument('node_class', help="The class of node to run.")
args = parser.parse_args()
class_name = args.node_class.capitalize()
# Verify that the specified Python file exists
filename = os.path.join('nodegen/node', args.node_class + '.py')
if not os.path.exists(filename):
print(f"Error: {filename} does not exist.")
return
# Import the module dynamically
module = importlib.import_module('nodegen.node.' + args.node_class)
# Get the class from the module
node_class = getattr(module, class_name)
# Instantiate the class and call the run_all method
node_instance = node_class()
node_instance.run_all()
if __name__ == "__main__":
main()
| https://github.com/gizatechxyz/orion |
nodegen/node/abs.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl
class Abs(RunAll):
@staticmethod
def abs_i32():
x = np.random.randint(-127, 127, (2, 2)).astype(np.int32)
y = abs(x)
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
name = "abs_i32"
make_test([x], y, "input_0.abs()", name)
@staticmethod
def abs_i8():
x = np.random.randint(-127, 127, (2, 2)).astype(np.int8)
y = abs(x)
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.I8, y.shape, y.flatten())
name = "abs_i8"
make_test([x], y, "input_0.abs()", name)
@staticmethod
def abs_fp8x23():
x = to_fp(np.random.randint(-127, 127, (2, 2)
).astype(np.int64), FixedImpl.FP8x23)
y = abs(x)
x = Tensor(Dtype.FP8x23, x.shape, x.flatten())
y = Tensor(Dtype.FP8x23, y.shape, y.flatten())
name = "abs_fp8x23"
make_test([x], y, "input_0.abs()", name)
@staticmethod
def abs_fp16x16():
x = to_fp(np.random.randint(-127, 127, (2, 2)
).astype(np.int64), FixedImpl.FP16x16)
y = abs(x)
x = Tensor(Dtype.FP16x16, x.shape, x.flatten())
y = Tensor(Dtype.FP16x16, y.shape, y.flatten())
name = "abs_fp16x16"
make_test([x], y, "input_0.abs()", name)
| https://github.com/gizatechxyz/orion |
nodegen/node/acos.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl
class Acos(RunAll):
@staticmethod
def acos_fp8x23():
x = np.random.uniform(-1, 1, (2, 2)).astype(np.float64)
y = np.arccos(x)
x = Tensor(Dtype.FP8x23, x.shape, to_fp(x.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(y.flatten(), FixedImpl.FP8x23))
name = "acos_fp8x23"
make_test([x], y, "input_0.acos()", name)
@staticmethod
def acos_fp16x16():
x = np.random.uniform(-1, 1, (2, 2)).astype(np.float64)
y = np.arccos(x)
x = Tensor(Dtype.FP16x16, x.shape, to_fp(x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(y.flatten(), FixedImpl.FP16x16))
name = "acos_fp16x16"
make_test([x], y, "input_0.acos()", name)
| https://github.com/gizatechxyz/orion |
nodegen/node/acosh.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl
class Acosh(RunAll):
@staticmethod
def acosh_fp8x23():
x = np.random.uniform(1, 5, (2, 2)).astype(np.float64)
y = np.arccosh(x)
x = Tensor(Dtype.FP8x23, x.shape, to_fp(
x.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(
y.flatten(), FixedImpl.FP8x23))
name = "acosh_fp8x23"
make_test([x], y, "input_0.acosh()", name)
@staticmethod
def acosh_fp16x16():
x = np.random.uniform(1, 5, (2, 2)).astype(np.float64)
y = np.arccosh(x)
x = Tensor(Dtype.FP16x16, x.shape, to_fp(
x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "acosh_fp16x16"
make_test([x], y, "input_0.acosh()", name)
| https://github.com/gizatechxyz/orion |
nodegen/node/add.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl
class Add(RunAll):
@staticmethod
def add_u32():
def default():
x = np.random.randint(0, 3, (3, 3, 3)).astype(np.uint32)
y = np.random.randint(0, 3, (3, 3, 3)).astype(np.uint32)
z = x + y
x = Tensor(Dtype.U32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
z = Tensor(Dtype.U32, z.shape, z.flatten())
name = "add_u32"
make_test([x, y], z, "input_0 + input_1", name)
def broadcast():
x = np.random.randint(0, 3, (3, 3, 3)).astype(np.uint32)
y = np.random.randint(0, 3, (1, 3, 1)).astype(np.uint32)
z = x + y
x = Tensor(Dtype.U32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
z = Tensor(Dtype.U32, z.shape, z.flatten())
name = "add_u32_broadcast"
make_test([x, y], z, "input_0 + input_1", name)
default()
broadcast()
@staticmethod
def add_i32():
def default():
x = np.random.randint(-3, 3, (3, 3, 3)).astype(np.int32)
y = np.random.randint(-3, 3, (3, 3, 3)).astype(np.int32)
z = x + y
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
z = Tensor(Dtype.I32, z.shape, z.flatten())
name = "add_i32"
make_test([x, y], z, "input_0 + input_1", name)
def broadcast():
x = np.random.randint(-3, 3, (3, 3, 3)).astype(np.int32)
y = np.random.randint(-3, 3, (1, 3, 1)).astype(np.int32)
z = x + y
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
z = Tensor(Dtype.I32, z.shape, z.flatten())
name = "add_i32_broadcast"
make_test([x, y], z, "input_0 + input_1", name)
default()
broadcast()
@staticmethod
def add_i8():
def default():
x = np.random.randint(-3, 3, (3, 3, 3)).astype(np.int8)
y = np.random.randint(-3, 3, (3, 3, 3)).astype(np.int8)
z = x + y
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.I8, y.shape, y.flatten())
z = Tensor(Dtype.I8, z.shape, z.flatten())
name = "add_i8"
make_test([x, y], z, "input_0 + input_1", name)
def broadcast():
x = np.random.randint(-3, 3, (3, 3, 3)).astype(np.int8)
y = np.random.randint(-3, 3, (1, 3, 1)).astype(np.int8)
z = x + y
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.I8, y.shape, y.flatten())
z = Tensor(Dtype.I8, z.shape, z.flatten())
name = "add_i8_broadcast"
make_test([x, y], z, "input_0 + input_1", name)
default()
broadcast()
@staticmethod
def add_fp8x23():
def default():
x = np.random.randint(-3, 3, (3, 3, 3)).astype(np.float64)
y = np.random.randint(-3, 3, (3, 3, 3)).astype(np.float64)
z = x + y
x = Tensor(Dtype.FP8x23, x.shape, to_fp(
x.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(
y.flatten(), FixedImpl.FP8x23))
z = Tensor(Dtype.FP8x23, z.shape, to_fp(
z.flatten(), FixedImpl.FP8x23))
name = "add_fp8x23"
make_test([x, y], z, "input_0 + input_1", name)
def broadcast():
x = np.random.randint(-3, 3, (3, 3, 3)).astype(np.float64)
y = np.random.randint(-3, 3, (1, 3, 1)).astype(np.float64)
z = x + y
x = Tensor(Dtype.FP8x23, x.shape, to_fp(
x.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(
y.flatten(), FixedImpl.FP8x23))
z = Tensor(Dtype.FP8x23, z.shape, to_fp(
z.flatten(), FixedImpl.FP8x23))
name = "add_fp8x23_broadcast"
make_test([x, y], z, "input_0 + input_1", name)
default()
broadcast()
@staticmethod
def add_fp16x16():
def default():
x = np.random.randint(-3, 3, (3, 3, 3)).astype(np.float64)
y = np.random.randint(-3, 3, (3, 3, 3)).astype(np.float64)
z = x + y
x = Tensor(Dtype.FP16x16, x.shape, to_fp(
x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
z = Tensor(Dtype.FP16x16, z.shape, to_fp(
z.flatten(), FixedImpl.FP16x16))
name = "add_fp16x16"
make_test([x, y], z, "input_0 + input_1", name)
def broadcast():
x = np.random.randint(-3, 3, (3, 3, 3)).astype(np.float64)
y = np.random.randint(-3, 3, (1, 3, 1)).astype(np.float64)
z = x + y
x = Tensor(Dtype.FP16x16, x.shape, to_fp(
x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
z = Tensor(Dtype.FP16x16, z.shape, to_fp(
z.flatten(), FixedImpl.FP16x16))
name = "add_fp16x16_broadcast"
make_test([x, y], z, "input_0 + input_1", name)
default()
broadcast()
| https://github.com/gizatechxyz/orion |
nodegen/node/and.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl
class And(RunAll):
@staticmethod
def and_bool():
def default():
x = (np.random.randn(3, 4) > 0).astype(bool)
y = (np.random.randn(3, 4) > 0).astype(bool)
z = np.logical_and(x, y)
x = Tensor(Dtype.BOOL, x.shape, x.flatten())
y = Tensor(Dtype.BOOL, y.shape, y.flatten())
z = Tensor(Dtype.BOOL, z.shape, z.flatten())
name = "and_bool"
make_test([x, y], z, "BoolTensor::and(@input_0, @input_1)", name)
def broadcast():
x = (np.random.randn(3, 4, 5) > 0).astype(bool)
y = (np.random.randn(3, 4, 5) > 0).astype(bool)
z = np.logical_and(x, y)
x = Tensor(Dtype.BOOL, x.shape, x.flatten())
y = Tensor(Dtype.BOOL, y.shape, y.flatten())
z = Tensor(Dtype.BOOL, z.shape, z.flatten())
name = "and_bool_broadcast"
make_test([x, y], z, "BoolTensor::and(@input_0, @input_1)", name)
default()
broadcast()
| https://github.com/gizatechxyz/orion |
nodegen/node/argmax.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl
def argmax_use_numpy(data: np.ndarray, axis: int = 0, keepdims: int = 1) -> np.ndarray:
result = np.argmax(data, axis=axis)
if keepdims == 1:
result = np.expand_dims(result, axis)
return result.astype(np.int64)
def argmax_use_numpy_select_last_index(
data: np.ndarray, axis: int = 0, keepdims: int = True
) -> np.ndarray:
data = np.flip(data, axis)
result = np.argmax(data, axis=axis)
result = data.shape[axis] - result - 1
if keepdims:
result = np.expand_dims(result, axis)
return result.astype(np.int64)
class Argmax(RunAll):
@staticmethod
def no_keepdims():
data = np.array([[2, 1], [3, 10]], dtype=np.float32)
axis = 1
keepdims = 0
result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
x = Tensor(Dtype.FP16x16, data.shape, data.flatten())
y = Tensor(Dtype.I32, result.shape, result.flatten())
name = "argmax_no_keepdims"
make_test(
[x], y, "input_0.argmax(1, Option::Some(false), Option::None(()))", name)
@staticmethod
def keepdims():
data = np.array([[2, 1], [3, 10]], dtype=np.float32)
axis = 1
keepdims = 1
result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
x = Tensor(Dtype.FP16x16, data.shape, data.flatten())
y = Tensor(Dtype.I32, result.shape, result.flatten())
name = "argmax_keepdims"
make_test(
[x], y, "input_0.argmax(1, Option::Some(true), Option::None(()))", name)
@staticmethod
def default_axes_keepdims():
data = np.array([[2, 1], [3, 10]], dtype=np.float32)
keepdims = 1
result = argmax_use_numpy(data, keepdims=keepdims)
x = Tensor(Dtype.FP16x16, data.shape, data.flatten())
y = Tensor(Dtype.I32, result.shape, result.flatten())
name = "argmax_default_axes_keepdims"
make_test(
[x], y, "input_0.argmax(0, Option::Some(true), Option::None(()))", name)
@staticmethod
def negative_axis_keepdims():
data = np.array([[2, 1], [3, 10]], dtype=np.float32)
axis = -1
keepdims = 1
result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
x = Tensor(Dtype.FP16x16, data.shape, data.flatten())
y = Tensor(Dtype.I32, result.shape, result.flatten())
name = "argmax_negative_axis_keepdims"
make_test(
[x], y, "input_0.argmax(-1, Option::Some(true), Option::None(()))", name)
@staticmethod
def no_keepdims_select_last_index():
data = np.array([[2, 2], [3, 10]], dtype=np.float32)
axis = 1
keepdims = 0
result = argmax_use_numpy_select_last_index(
data, axis=axis, keepdims=keepdims)
x = Tensor(Dtype.FP16x16, data.shape, data.flatten())
y = Tensor(Dtype.I32, result.shape, result.flatten())
name = "argmax_no_keepdims_select_last_index"
make_test(
[x], y, "input_0.argmax(1, Option::Some(false), Option::Some(true))", name)
@staticmethod
def keepdims_select_last_index():
data = np.array([[2, 2], [3, 10]], dtype=np.float32)
axis = 1
keepdims = 1
result = argmax_use_numpy_select_last_index(
data, axis=axis, keepdims=keepdims)
x = Tensor(Dtype.FP16x16, data.shape, data.flatten())
y = Tensor(Dtype.I32, result.shape, result.flatten())
name = "argmax_keepdims_select_last_index"
make_test(
[x], y, "input_0.argmax(1, Option::Some(true), Option::Some(true))", name)
@staticmethod
def default_axes_keepdims_select_last_index():
data = np.array([[2, 2], [3, 10]], dtype=np.float32)
keepdims = 1
result = argmax_use_numpy_select_last_index(data, keepdims=keepdims)
x = Tensor(Dtype.FP16x16, data.shape, data.flatten())
y = Tensor(Dtype.I32, result.shape, result.flatten())
name = "argmax_default_axes_keepdims_select_last_index"
make_test(
[x], y, "input_0.argmax(0, Option::Some(true), Option::Some(true))", name)
@staticmethod
def negative_axis_keepdims_select_last_index():
data = np.array([[2, 2], [3, 10]], dtype=np.float32)
axis = -1
keepdims = 1
result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
x = Tensor(Dtype.FP16x16, data.shape, data.flatten())
y = Tensor(Dtype.I32, result.shape, result.flatten())
name = "argmax_negative_axis_keepdims_select_last_index"
make_test(
[x], y, "input_0.argmax(-1, Option::Some(true), Option::Some(true))", name)
| https://github.com/gizatechxyz/orion |
nodegen/node/argmin.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl
def argmin_use_numpy(data: np.ndarray, axis: int = 0, keepdims: int = 1, dtype=np.int64) -> np.ndarray:
result = np.argmin(data, axis=axis)
if keepdims == 1:
result = np.expand_dims(result, axis)
return result.astype(dtype)
def argmin_use_numpy_select_last_index(
data: np.ndarray, axis: int = 0, keepdims: int = True, dtype=np.int64
) -> np.ndarray:
data = np.flip(data, axis)
result = np.argmin(data, axis=axis)
result = data.shape[axis] - result - 1
if keepdims:
result = np.expand_dims(result, axis)
return result.astype(dtype)
class Argmin(RunAll):
@staticmethod
def argmin_u32():
def argmin_1D():
def default_params():
x = np.random.randint(0, 255, (3)).astype(np.uint32)
y = argmin_use_numpy(x, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.U32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_u32_1D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = np.random.randint(0, 255, (3)).astype(np.uint32)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.U32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_u32_1D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = np.random.randint(0, 255, (3)).astype(np.uint32)
y = argmin_use_numpy_select_last_index(
x, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.U32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_u32_1D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_1D()
def argmin_2D():
def default_params():
x = np.random.randint(0, 255, (2, 2)).astype(np.uint32)
y = argmin_use_numpy(x, dtype=np.uint32)
x = Tensor(Dtype.U32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_u32_2D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = np.random.randint(0, 255, (2, 2)).astype(np.uint32)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32)
x = Tensor(Dtype.U32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_u32_2D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = np.random.randint(0, 255, (2, 2)).astype(np.uint32)
y = argmin_use_numpy_select_last_index(
x, dtype=np.uint32)
x = Tensor(Dtype.U32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_u32_2D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_2D()
def argmin_3D():
def default_params():
x = np.random.randint(0, 255, (2, 2, 2)).astype(np.uint32)
y = argmin_use_numpy(x, dtype=np.uint32)
x = Tensor(Dtype.U32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_u32_3D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = np.random.randint(0, 255, (2, 2, 2)).astype(np.uint32)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32)
x = Tensor(Dtype.U32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_u32_3D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = np.random.randint(0, 255, (2, 2, 2)).astype(np.uint32)
y = argmin_use_numpy_select_last_index(
x, dtype=np.uint32)
x = Tensor(Dtype.U32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_u32_3D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_3D()
@staticmethod
def argmin_i32():
def argmin_1D():
def default_params():
x = np.random.randint(-127, 127, (3)).astype(np.int32)
y = argmin_use_numpy(x, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i32_1D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = np.random.randint(-127, 127, (3)).astype(np.int32)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i32_1D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = np.random.randint(0, 255, (3)).astype(np.int32)
y = argmin_use_numpy_select_last_index(
x, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i32_1D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_1D()
def argmin_2D():
def default_params():
x = np.random.randint(-127, 127, (2, 2)).astype(np.int32)
y = argmin_use_numpy(x, dtype=np.uint32)
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i32_2D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = np.random.randint(-127, 127, (2, 2)).astype(np.int32)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32)
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i32_2D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = np.random.randint(-127, 127, (2, 2)).astype(np.int32)
y = argmin_use_numpy_select_last_index(
x, dtype=np.int32)
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i32_2D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_2D()
def argmin_3D():
def default_params():
x = np.random.randint(-127, 127, (2, 2, 2)).astype(np.int32)
y = argmin_use_numpy(x, dtype=np.uint32)
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i32_3D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = np.random.randint(-127, 127, (2, 2, 2)).astype(np.int32)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32)
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i32_3D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = np.random.randint(-127, 127, (2, 2, 2)).astype(np.int32)
y = argmin_use_numpy_select_last_index(
x, dtype=np.uint32)
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i32_3D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_3D()
@staticmethod
def argmin_i8():
def argmin_1D():
def default_params():
x = np.random.randint(-127, 127, (3)).astype(np.int8)
y = argmin_use_numpy(x, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i8_1D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = np.random.randint(-127, 127, (3)).astype(np.int8)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i8_1D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = np.random.randint(0, 255, (3)).astype(np.int8)
y = argmin_use_numpy_select_last_index(
x, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i8_1D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_1D()
def argmin_2D():
def default_params():
x = np.random.randint(-127, 127, (2, 2)).astype(np.int8)
y = argmin_use_numpy(x, dtype=np.uint32)
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i8_2D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = np.random.randint(-127, 127, (2, 2)).astype(np.int8)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32)
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i8_2D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = np.random.randint(-127, 127, (2, 2)).astype(np.int8)
y = argmin_use_numpy_select_last_index(
x, dtype=np.int8)
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i8_2D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_2D()
def argmin_3D():
def default_params():
x = np.random.randint(-127, 127, (2, 2, 2)).astype(np.int8)
y = argmin_use_numpy(x, dtype=np.uint32)
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i8_3D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = np.random.randint(-127, 127, (2, 2, 2)).astype(np.int8)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32)
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i8_3D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = np.random.randint(-127, 127, (2, 2, 2)).astype(np.int8)
y = argmin_use_numpy_select_last_index(
x, dtype=np.uint32)
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_i8_3D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_3D()
@staticmethod
def argmin_fp16x16():
def argmin_1D():
def default_params():
x = to_fp(np.random.randint(-127, 127, (3)
).astype(np.int8), FixedImpl.FP16x16)
y = argmin_use_numpy(x, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.FP16x16, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp16x16_1D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = to_fp(np.random.randint(-127, 127, (3)
).astype(np.int8), FixedImpl.FP16x16)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.FP16x16, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp16x16_1D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = to_fp(np.random.randint(0, 255, (3)).astype(
np.int8), FixedImpl.FP16x16)
y = argmin_use_numpy_select_last_index(
x, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.FP16x16, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp16x16_1D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_1D()
def argmin_2D():
def default_params():
x = to_fp(np.random.randint(-127, 127, (2, 2)
).astype(np.int8), FixedImpl.FP16x16)
y = argmin_use_numpy(x, dtype=np.uint32)
x = Tensor(Dtype.FP16x16, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp16x16_2D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = to_fp(np.random.randint(-127, 127, (2, 2)
).astype(np.int8), FixedImpl.FP16x16)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32)
x = Tensor(Dtype.FP16x16, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp16x16_2D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = to_fp(np.random.randint(-127, 127, (2, 2)
).astype(np.int8), FixedImpl.FP16x16)
y = argmin_use_numpy_select_last_index(
x, dtype=np.int8)
x = Tensor(Dtype.FP16x16, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp16x16_2D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_2D()
def argmin_3D():
def default_params():
x = to_fp(np.random.randint(-127, 127, (2, 2, 2)
).astype(np.int8), FixedImpl.FP16x16)
y = argmin_use_numpy(x, dtype=np.uint32)
x = Tensor(Dtype.FP16x16, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp16x16_3D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = to_fp(np.random.randint(-127, 127, (2, 2, 2)
).astype(np.int8), FixedImpl.FP16x16)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32)
x = Tensor(Dtype.FP16x16, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp16x16_3D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = to_fp(np.random.randint(-127, 127, (2, 2, 2)
).astype(np.int8), FixedImpl.FP16x16)
y = argmin_use_numpy_select_last_index(
x, dtype=np.uint32)
x = Tensor(Dtype.FP16x16, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp16x16_3D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_3D()
@staticmethod
def argmin_fp8x23():
def argmin_1D():
def default_params():
x = to_fp(np.random.randint(-127, 127, (3)
).astype(np.int8), FixedImpl.FP8x23)
y = argmin_use_numpy(x, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.FP8x23, x.shape,
x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp8x23_1D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = to_fp(np.random.randint(-127, 127, (3)
).astype(np.int8), FixedImpl.FP8x23)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.FP8x23, x.shape,
x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp8x23_1D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = to_fp(np.random.randint(0, 255, (3)).astype(
np.int8), FixedImpl.FP8x23)
y = argmin_use_numpy_select_last_index(
x, dtype=np.uint32).reshape((1))
x = Tensor(Dtype.FP8x23, x.shape,
x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp8x23_1D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_1D()
def argmin_2D():
def default_params():
x = to_fp(np.random.randint(-127, 127, (2, 2)
).astype(np.int8), FixedImpl.FP8x23)
y = argmin_use_numpy(x, dtype=np.uint32)
x = Tensor(Dtype.FP8x23, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp8x23_2D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = to_fp(np.random.randint(-127, 127, (2, 2)
).astype(np.int8), FixedImpl.FP8x23)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32)
x = Tensor(Dtype.FP8x23, x.shape,
x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp8x23_2D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = to_fp(np.random.randint(-127, 127, (2, 2)
).astype(np.int8), FixedImpl.FP8x23)
y = argmin_use_numpy_select_last_index(
x, dtype=np.int8)
x = Tensor(Dtype.FP8x23, x.shape,
x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp8x23_2D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_2D()
def argmin_3D():
def default_params():
x = to_fp(np.random.randint(-127, 127, (2, 2, 2)
).astype(np.int8), FixedImpl.FP8x23)
y = argmin_use_numpy(x, dtype=np.uint32)
x = Tensor(Dtype.FP8x23, x.shape,
x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp8x23_3D_default"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::None(()))", name)
def keepdims_false():
x = to_fp(np.random.randint(-127, 127, (2, 2, 2)
).astype(np.int8), FixedImpl.FP8x23)
y = argmin_use_numpy(
x, keepdims=0, dtype=np.uint32)
x = Tensor(Dtype.FP8x23, x.shape,
x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp8x23_3D_keepdims_false"
make_test(
[x], y, "input_0.argmin(0, Option::Some(false), Option::None(()))", name)
def last_index():
x = to_fp(np.random.randint(-127, 127, (2, 2, 2)
).astype(np.int8), FixedImpl.FP8x23)
y = argmin_use_numpy_select_last_index(
x, dtype=np.uint32)
x = Tensor(Dtype.FP8x23, x.shape,
x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "argmin_fp8x23_3D_last_index"
make_test(
[x], y, "input_0.argmin(0, Option::None(()), Option::Some(true))", name)
default_params()
keepdims_false()
last_index()
argmin_3D()
| https://github.com/gizatechxyz/orion |
nodegen/node/array_feature_extractor.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl
class Array_feature_extractor(RunAll):
@staticmethod
def array_feature_extractor_3D():
def array_feature_extractor_i32():
x = np.random.randint(-3, 3, (2, 3, 4)).astype(np.int32)
y = np.array([1, 3]).astype(np.uint32)
z = (x[..., y])
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
z = Tensor(Dtype.I32, z.shape, z.flatten())
name = "array_feature_extractor_3D_i32"
make_test([x, y], z, "TensorTrait::array_feature_extractor(@input_0, input_1)", name)
def array_feature_extractor_fp8x23():
x = np.random.randint(-3, 3, (2, 3, 4)).astype(np.float64)
y = np.array([1, 3]).astype(np.uint32)
z = (x[..., y])
x = Tensor(Dtype.FP8x23, x.shape, to_fp(
x.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.U32, y.shape, y.flatten())
z = Tensor(Dtype.FP8x23, z.shape, to_fp(
z.flatten(), FixedImpl.FP8x23))
name = "array_feature_extractor_3D_fp8x23"
make_test([x, y], z, "TensorTrait::array_feature_extractor(@input_0, input_1)", name)
def array_feature_extractor_fp16x16():
x = np.random.randint(-3, 3, (2, 3, 4)).astype(np.float64)
y = np.array([1, 3]).astype(np.uint32)
z = (x[..., y])
x = Tensor(Dtype.FP16x16, x.shape, to_fp(
x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.U32, y.shape, y.flatten())
z = Tensor(Dtype.FP16x16, z.shape, to_fp(
z.flatten(), FixedImpl.FP16x16))
name = "array_feature_extractor_3D_fp16x16"
make_test([x, y], z, "TensorTrait::array_feature_extractor(@input_0, input_1)", name)
array_feature_extractor_i32()
array_feature_extractor_fp8x23()
array_feature_extractor_fp16x16()
@staticmethod
def array_feature_extractor_2D():
def array_feature_extractor_i32():
x = np.random.randint(-3, 3, (3, 4)).astype(np.int32)
y = np.array([1, 3]).astype(np.uint32)
z = (x[..., y])
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
z = Tensor(Dtype.I32, z.shape, z.flatten())
name = "array_feature_extractor_2D_i32"
make_test([x, y], z, "TensorTrait::array_feature_extractor(@input_0, input_1)", name)
def array_feature_extractor_fp8x23():
x = np.random.randint(-3, 3, (3, 4)).astype(np.float64)
y = np.array([1, 3]).astype(np.uint32)
z = (x[..., y])
x = Tensor(Dtype.FP8x23, x.shape, to_fp(
x.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.U32, y.shape, y.flatten())
z = Tensor(Dtype.FP8x23, z.shape, to_fp(
z.flatten(), FixedImpl.FP8x23))
name = "array_feature_extractor_2D_fp8x23"
make_test([x, y], z, "TensorTrait::array_feature_extractor(@input_0, input_1)", name)
def array_feature_extractor_fp16x16():
x = np.random.randint(-3, 3, (3, 4)).astype(np.float64)
y = np.array([1, 3]).astype(np.uint32)
z = (x[..., y])
x = Tensor(Dtype.FP16x16, x.shape, to_fp(
x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.U32, y.shape, y.flatten())
z = Tensor(Dtype.FP16x16, z.shape, to_fp(
z.flatten(), FixedImpl.FP16x16))
name = "array_feature_extractor_2D_fp16x16"
make_test([x, y], z, "TensorTrait::array_feature_extractor(@input_0, input_1)", name)
array_feature_extractor_i32()
array_feature_extractor_fp8x23()
array_feature_extractor_fp16x16()
@staticmethod
def array_feature_extractor_1D():
def array_feature_extractor_i32():
x = np.random.randint(-3, 3, (4)).astype(np.int32)
y = np.array([1, 3]).astype(np.uint32)
z = (x[..., y])
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
z = Tensor(Dtype.I32, z.shape, z.flatten())
name = "array_feature_extractor_1D_i32"
make_test([x, y], z, "TensorTrait::array_feature_extractor(@input_0, input_1)", name)
def array_feature_extractor_fp8x23():
x = np.random.randint(-3, 3, (4)).astype(np.float64)
y = np.array([1, 3]).astype(np.uint32)
z = (x[..., y])
x = Tensor(Dtype.FP8x23, x.shape, to_fp(
x.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.U32, y.shape, y.flatten())
z = Tensor(Dtype.FP8x23, z.shape, to_fp(
z.flatten(), FixedImpl.FP8x23))
name = "array_feature_extractor_1D_fp8x23"
make_test([x, y], z, "TensorTrait::array_feature_extractor(@input_0, input_1)", name)
def array_feature_extractor_fp16x16():
x = np.random.randint(-3, 3, (4)).astype(np.float64)
y = np.array([1, 3]).astype(np.uint32)
z = (x[..., y])
x = Tensor(Dtype.FP16x16, x.shape, to_fp(
x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.U32, y.shape, y.flatten())
z = Tensor(Dtype.FP16x16, z.shape, to_fp(
z.flatten(), FixedImpl.FP16x16))
name = "array_feature_extractor_1D_fp16x16"
make_test([x, y], z, "TensorTrait::array_feature_extractor(@input_0, input_1)", name)
array_feature_extractor_i32()
array_feature_extractor_fp8x23()
array_feature_extractor_fp16x16() | https://github.com/gizatechxyz/orion |
nodegen/node/asin.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl
class Asin(RunAll):
@staticmethod
def asin_fp8x23():
x = np.random.uniform(-1, 1, (2, 2)).astype(np.float64)
y = np.arcsin(x)
x = Tensor(Dtype.FP8x23, x.shape, to_fp(x.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(y.flatten(), FixedImpl.FP8x23))
name = "asin_fp8x23"
make_test([x], y, "input_0.asin()", name)
@staticmethod
def asin_fp16x16():
x = np.random.uniform(-1, 1, (2, 2)).astype(np.float64)
y = np.arcsin(x)
x = Tensor(Dtype.FP16x16, x.shape, to_fp(x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(y.flatten(), FixedImpl.FP16x16))
name = "asin_fp16x16"
make_test([x], y, "input_0.asin()", name)
| https://github.com/gizatechxyz/orion |
nodegen/node/asinh.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl
class Asinh(RunAll):
@staticmethod
def asinh_fp8x23():
x = np.random.uniform(1, 5, (2, 2)).astype(np.float64)
y = np.arcsinh(x)
x = Tensor(Dtype.FP8x23, x.shape, to_fp(
x.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(
y.flatten(), FixedImpl.FP8x23))
name = "asinh_fp8x23"
make_test([x], y, "input_0.asinh()", name)
@staticmethod
def asinh_fp16x16():
x = np.random.uniform(1, 5, (2, 2)).astype(np.float64)
y = np.arcsinh(x)
x = Tensor(Dtype.FP16x16, x.shape, to_fp(
x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "asinh_fp16x16"
make_test([x], y, "input_0.asinh()", name)
| https://github.com/gizatechxyz/orion |
nodegen/node/atan.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl
class Atan(RunAll):
@staticmethod
def atan_fp8x23():
x = np.random.uniform(-10, 127, (2, 2)).astype(np.float64)
y = np.arctan(x)
x = Tensor(Dtype.FP8x23, x.shape, to_fp(
x.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(
y.flatten(), FixedImpl.FP8x23))
name = "atan_fp8x23"
make_test([x], y, "input_0.atan()", name)
@staticmethod
def atan_fp16x16():
x = np.random.uniform(-10, 127, (2, 2)).astype(np.float64)
y = np.arctan(x)
x = Tensor(Dtype.FP16x16, x.shape, to_fp(
x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "atan_fp16x16"
make_test([x], y, "input_0.atan()", name)
| https://github.com/gizatechxyz/orion |
nodegen/node/binarizer.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_node, make_test, to_fp, Tensor, Dtype, FixedImpl
class Binarizer(RunAll):
@staticmethod
def binarizer_fp8x23():
x = np.random.uniform(-3, 3, (3, 3, 3)).astype(np.float64)
threshold = np.float64(1)
y = (x > threshold).astype(np.float64)
x = Tensor(Dtype.FP8x23, x.shape, to_fp(
x.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(
y.flatten(), FixedImpl.FP8x23))
name = "binarizer_fp8x23"
make_node([x], [y], name)
make_test([x], y, "TensorTrait::binarizer(@input_0, Option::Some(FixedTrait::new(8388608, false));", name)
@staticmethod
def binarizer_fp16x16():
x = np.random.uniform(-3, 3, (3, 3, 3)).astype(np.float64)
threshold = np.float64(1)
y = (x > threshold).astype(np.float64)
x = Tensor(Dtype.FP16x16, x.shape, to_fp(
x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "binarizer_fp16x16"
make_node([x], [y], name)
make_test([x], y, "TensorTrait::binarizer(@input_0, Option::Some(FixedTrait::new(65536, false));", name)
| https://github.com/gizatechxyz/orion |
nodegen/node/blackman_window.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl, Trait, get_data_statement
def blackman_window(size, output_datatype=None, periodic=None) -> np.ndarray: # type: ignore
if periodic == 1:
N_1 = size
else:
N_1 = size - 1
ni = np.arange(size, dtype=output_datatype)
alpha = 0.42
beta = 0.08
y = np.cos((ni * (np.float64(np.pi).astype(output_datatype) * 2)) / N_1).astype(output_datatype) * (-0.5)
y += np.cos((ni * (np.float64(np.pi).astype(output_datatype) * 4)) / N_1) * beta
y += alpha
return y.astype(output_datatype)
class Blackman_window(RunAll):
@staticmethod
# We test here with fp8x23 implementation.
def fp8x23():
args = [3]
# x = np.float64(4)
args_str = get_data_statement(to_fp(np.array(args).flatten(), FixedImpl.FP8x23), Dtype.FP8x23)
y = blackman_window(*args, np.float64)
# Convert the floats values in `y` to fixed points with `to_fp` method:
y = Tensor(Dtype.FP8x23, y.shape, to_fp(y.flatten(), FixedImpl.FP8x23))
# Define the name of the generated folder.
name = "blackman_window_fp8x23"
# Invoke `make_test` method to generate corresponding Cairo tests:
make_test(
[], # List of input tensors.
y, # The expected output result.
f"TensorTrait::blackman_window({','.join(args_str)}, Option::Some(0))", # The code signature.
name # The name of the generated folder.
)
@staticmethod
# We test here with fp16x16 implementation.
def fp16x16():
print(get_data_statement(to_fp(np.array([np.pi]).flatten(), FixedImpl.FP16x16), Dtype.FP16x16))
args = [3]
# x = np.float64(4)
args_str = get_data_statement(to_fp(np.array(args).flatten(), FixedImpl.FP16x16), Dtype.FP16x16)
y = blackman_window(*args, np.float16, 1)
# Convert the floats values in `y` to fixed points with `to_fp` method:
y = Tensor(Dtype.FP16x16, y.shape, to_fp(y.flatten(), FixedImpl.FP16x16))
# Define the name of the generated folder.
name = "blackman_window_fp16x16"
# Invoke `make_test` method to generate corresponding Cairo tests:
make_test(
[], # List of input tensors.
y, # The expected output result.
f"TensorTrait::blackman_window({','.join(args_str)}, Option::Some(1))", # The code signature.
name # The name of the generated folder.
)
# @staticmethod
# # We test here with i8 implementation.
# def i8():
# print(get_data_statement(np.array([np.pi]).flatten(), Dtype.I8))
# args = [5]
# # x = np.float64(4)
# args_str = get_data_statement(np.array(args).flatten(), Dtype.I8)
# y = blackman_window(*args, np.int8)
# print(y)
# # Convert the floats values in `y` to fixed points with `to_fp` method:
# y = Tensor(Dtype.I8, y.shape, y.flatten())
# # Define the name of the generated folder.
# name = "blackman_window_i8"
# # Invoke `make_test` method to generate corresponding Cairo tests:
# make_test(
# [], # List of input tensors.
# y, # The expected output result.
# f"TensorTrait::blackman_window({','.join(args_str)}, Option::Some(1))", # The code signature.
# name # The name of the generated folder.
# )
# @staticmethod
# # We test here with i32 implementation.
# def i32():
# print(get_data_statement(np.array([np.pi]).flatten(), Dtype.I32))
# args = [4]
# # x = np.float64(4)
# args_str = get_data_statement(np.array(args).flatten(), Dtype.I32)
# y = blackman_window(*args, np.int32)
# print(y)
# # Convert the floats values in `y` to fixed points with `to_fp` method:
# y = Tensor(Dtype.I32, y.shape, y.flatten())
# # Define the name of the generated folder.
# name = "blackman_window_i32"
# # Invoke `make_test` method to generate corresponding Cairo tests:
# make_test(
# [], # List of input tensors.
# y, # The expected output result.
# f"TensorTrait::blackman_window({','.join(args_str)}, Option::Some(0))", # The code signature.
# name # The name of the generated folder.
# )
# @staticmethod
# # We test here with u32 implementation.
# def u32():
# print(get_data_statement(np.array([np.pi]).flatten(), Dtype.U32))
# args = [4]
# # x = np.float64(4)
# args_str = get_data_statement(np.array(args).flatten(), Dtype.U32)
# y = blackman_window(*args, np.uint32)
# print(y)
# # Convert the floats values in `y` to fixed points with `to_fp` method:
# y = Tensor(Dtype.U32, y.shape, y.flatten())
# # Define the name of the generated folder.
# name = "blackman_window_u32"
# # Invoke `make_test` method to generate corresponding Cairo tests:
# make_test(
# [], # List of input tensors.
# y, # The expected output result.
# f"TensorTrait::blackman_window({','.join(args_str)}, Option::Some(0))", # The code signature.
# name # The name of the generated folder.
# )
| https://github.com/gizatechxyz/orion |
nodegen/node/ceil.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl
class Ceil(RunAll):
@staticmethod
def ceil_fp8x23():
x = np.random.uniform(-1, 1, (2, 2)).astype(np.float64)
y = np.ceil(x)
x = Tensor(Dtype.FP8x23, x.shape, to_fp(x.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(y.flatten(), FixedImpl.FP8x23))
name = "ceil_fp8x23"
make_test([x], y, "input_0.ceil()", name)
@staticmethod
def ceil_fp16x16():
x = np.random.uniform(-1, 1, (2, 2)).astype(np.float64)
y = np.ceil(x)
x = Tensor(Dtype.FP16x16, x.shape, to_fp(x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(y.flatten(), FixedImpl.FP16x16))
name = "ceil_fp16x16"
make_test([x], y, "input_0.ceil()", name)
| https://github.com/gizatechxyz/orion |
nodegen/node/clip.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl
class Clip(RunAll):
@staticmethod
def clip_u32():
def clip_2D():
x = np.random.randint(0, 255, (2, 4)).astype(np.uint32)
y = np.clip(x, np.uint32(10), np.uint32(20))
x = Tensor(Dtype.U32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "clip_u32_2d"
make_test(
[x], y, "input_0.clip(Option::Some(10_u32), Option::Some(20_u32))", name)
def clip_3D():
x = np.random.randint(0, 255, (20, 10, 5)).astype(np.uint32)
y = np.clip(x, np.uint32(10), np.uint32(20))
x = Tensor(Dtype.U32, x.shape, x.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "clip_u32_3d"
make_test(
[x], y, "input_0.clip(Option::Some(10_u32), Option::Some(20_u32))", name)
clip_2D()
clip_3D()
@staticmethod
def clip_i32():
def clip_2D():
x = np.random.randint(-127, 127, (2, 4)).astype(np.int32)
y = np.clip(x, np.int32(-10), np.int32(20))
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
name = "clip_i32_2d"
make_test(
[x], y, "input_0.clip(Option::Some(-10_i32), Option::Some(20_i32))", name)
def clip_3D():
x = np.random.randint(-127, 127, (20, 10, 5)).astype(np.int32)
y = np.clip(x, np.int32(-10), np.int32(20))
x = Tensor(Dtype.I32, x.shape, x.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
name = "clip_i32_3d"
make_test(
[x], y, "input_0.clip(Option::Some(-10_i32), Option::Some(20_i32))", name)
clip_2D()
clip_3D()
@staticmethod
def clip_i8():
def clip_2D():
x = np.random.randint(-127, 127, (2, 4)).astype(np.int8)
y = np.clip(x, np.int8(-10), np.int8(20))
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.I8, y.shape, y.flatten())
name = "clip_i8_2d"
make_test(
[x], y, "input_0.clip(Option::Some(-10_i8), Option::Some(20_i8))", name)
def clip_3D():
x = np.random.randint(-127, 127, (20, 10, 5)).astype(np.int8)
y = np.clip(x, np.int8(-10), np.int8(20))
x = Tensor(Dtype.I8, x.shape, x.flatten())
y = Tensor(Dtype.I8, y.shape, y.flatten())
name = "clip_i8_3d"
make_test(
[x], y, "input_0.clip(Option::Some(-10_i8), Option::Some(20_i8))", name)
clip_2D()
clip_3D()
@staticmethod
def clip_fp8x23():
def clip_2D():
x = to_fp(np.random.randint(-127, 127, (2, 4)
).astype(np.int64), FixedImpl.FP8x23)
y = np.clip(x, to_fp(np.int64(-10), FixedImpl.FP8x23), to_fp(np.int64(20), FixedImpl.FP8x23))
x = Tensor(Dtype.FP8x23, x.shape, x.flatten())
y = Tensor(Dtype.FP8x23, y.shape, y.flatten())
name = "clip_fp8x23_2d"
make_test(
[x], y, "input_0.clip(Option::Some(FP8x23 { mag: 83886080, sign: true }), Option::Some(FP8x23 { mag: 167772160, sign: false }))", name)
def clip_3D():
x = to_fp(np.random.randint(-127, 127, (20, 10, 5)
).astype(np.int64), FixedImpl.FP8x23)
y = np.clip(x, to_fp(np.int64(-10), FixedImpl.FP8x23), to_fp(np.int64(20), FixedImpl.FP8x23))
x = Tensor(Dtype.FP8x23, x.shape, x.flatten())
y = Tensor(Dtype.FP8x23, y.shape, y.flatten())
name = "clip_fp8x23_3d"
make_test(
[x], y, "input_0.clip(Option::Some(FP8x23 { mag: 83886080, sign: true }), Option::Some(FP8x23 { mag: 167772160, sign: false }))", name)
clip_2D()
clip_3D()
@staticmethod
def clip_fp16x16():
def clip_2D():
x = to_fp(np.random.randint(-127, 127, (2, 4)
).astype(np.int64), FixedImpl.FP16x16)
y = np.clip(x, to_fp(np.int64(-10), FixedImpl.FP16x16), to_fp(np.int64(20), FixedImpl.FP16x16))
x = Tensor(Dtype.FP16x16, x.shape, x.flatten())
y = Tensor(Dtype.FP16x16, y.shape, y.flatten())
name = "clip_fp16x16_2d"
make_test(
[x], y, "input_0.clip(Option::Some(FP16x16 { mag: 655360, sign: true }), Option::Some(FP16x16 { mag: 1310720, sign: false }))", name)
def clip_3D():
x = to_fp(np.random.randint(-127, 127, (20, 10, 5)
).astype(np.int64), FixedImpl.FP16x16)
y = np.clip(x, to_fp(np.int64(-10), FixedImpl.FP16x16), to_fp(np.int64(20), FixedImpl.FP16x16))
x = Tensor(Dtype.FP16x16, x.shape, x.flatten())
y = Tensor(Dtype.FP16x16, y.shape, y.flatten())
name = "clip_fp16x16_3d"
make_test(
[x], y, "input_0.clip(Option::Some(FP16x16 { mag: 655360, sign: true }), Option::Some(FP16x16 { mag: 1310720, sign: false }))", name)
clip_2D()
clip_3D()
| https://github.com/gizatechxyz/orion |
nodegen/node/col2im.py |
import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl, Trait
def col2im(data, image_shape, block_shape, dilations=None, pads=None, strides=None): # type: ignore
if dilations is None:
dilations = [1 for s in image_shape]
if pads is None:
pads = [0 for s in image_shape] * 2
if strides is None:
strides = [1 for s in image_shape]
bl = np.prod(block_shape)
C = data.shape[1] // bl
data = data.reshape(data.shape[:1] + (C,) + (bl,) + data.shape[2:])
ks = tuple(block_shape)
res = None
for n in range(data.shape[0]):
for c in range(data.shape[1]):
out = col2im_naive_implementation(
data[n, c, ...], image_shape, ks, dilations, pads, strides
)
if res is None:
new_shape = data.shape[:2] + out.shape
res = np.empty(new_shape, dtype=data.dtype)
res[n, c, ...] = out
return (res,) # type: ignore
def _get_indices(i, shape):
res = np.empty((len(shape),), dtype=np.int64)
k = len(shape) - 1
while k > 0:
m = i % shape[k]
res[k] = m
i -= m
i /= shape[k]
k -= 1
res[0] = i
return res
def _col2im_shape_check(X, output_shape, kernel_shape, dilations, pads, strides): # type: ignore
n_input_plane = X.shape[0]
kernel_size = np.prod(kernel_shape)
if n_input_plane % kernel_size != 0:
raise ValueError(
f"Expected size of input's dimension 1 to be divisible by the "
f"product of kernel_size={kernel_size}, "
f"but got input.size(1)={n_input_plane} "
f"and kernel_shape={kernel_shape}, X.shape={X.shape}, output_shape={output_shape}."
)
input_length = X.shape[1]
n_dims = len(output_shape)
n_blocks = []
for i in range(n_dims):
n_block = (
output_shape[i]
+ pads[i, :].sum()
- dilations[i] * (kernel_shape[i] - 1)
- 1
) // strides[i] + 1
n_blocks.append(n_block)
block_size = np.prod(n_blocks)
if input_length != block_size:
raise ValueError(
f"Given n_input_plane={n_input_plane}, X.shape={X.shape}, "
f"output_shape={output_shape}, kernel_shape={kernel_shape}, "
f"dilations={dilations}, pads={pads}, strides={strides}, "
f"expected size of input's dimension 2 to match the calculated number of "
f"sliding blocks {n_blocks} = {block_size}, "
f"but got input.size(2)={input_length}.",
)
def col2im_naive_implementation(data, image_shape, kernel_shape, dilations, pads, strides): # type: ignore
n_dims = len(pads) // 2
new_pads = np.array([(pads[i], pads[i + n_dims]) for i in range(n_dims)])
_col2im_shape_check(data, image_shape, kernel_shape, dilations, new_pads, strides)
data_col = data
data_im = np.zeros(image_shape, dtype=data.dtype)
dim_col = []
for i in range(n_dims):
col = (
image_shape[i]
+ new_pads[i, :].sum()
- (dilations[i] * (kernel_shape[i] - 1) + 1)
) // strides[i] + 1
dim_col.append(col)
kernel_size = np.prod(kernel_shape)
col_size = np.prod(dim_col)
for c_col in range(kernel_size):
offset = _get_indices(c_col, kernel_shape)
for col in range(col_size):
ind_col = _get_indices(col, dim_col)
ind_im = []
for i in range(n_dims):
ind = (
ind_col[i] * strides[i] - new_pads[i, 0] + offset[i] * dilations[i]
)
ind_im.append(ind)
if not _is_out(ind_im, data_im.shape):
data_im[tuple(ind_im)] += data_col[c_col, col]
return data_im
def _is_out(ind, shape):
for i, s in zip(ind, shape):
if i < 0:
return True
if i >= s:
return True
return False
class Col2im(RunAll):
@staticmethod
def export_col2im() -> None:
x = np.array(
[
[
[1.0, 6.0, 11.0, 16.0, 21.0], # (1, 5, 5)
[2.0, 7.0, 12.0, 17.0, 22.0],
[3.0, 8.0, 13.0, 18.0, 23.0],
[4.0, 9.0, 14.0, 19.0, 24.0],
[5.0, 0.0, 15.0, 20.0, 25.0],
]
]
).astype(np.float32)
image_shape = np.array([5, 5]).astype(np.int64)
block_shape = np.array([1, 5]).astype(np.int64)
y = col2im(x,image_shape,block_shape)
y = np.array(y[0])
x = Tensor(Dtype.FP16x16, x.shape, to_fp(x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(y.flatten(), FixedImpl.FP16x16))
name = "col2im"
func_sig = "NNTrait::col2im("
func_sig += "@input_0,"
func_sig += "array![5, 5].span(),"
func_sig += "array![1, 5].span(),"
func_sig += "Option::None,"
func_sig += "Option::None,"
func_sig += "Option::None)"
make_test(
[x], y, func_sig, name, Trait.NN)
@staticmethod
def export_col2im_strides() -> None:
x = np.array(
[
[
[0.0, 0.0, 0.0, 0.0], # (1, 9, 4)
[1.0, 1.0, 1.0, 1.0],
[1.0, 1.0, 1.0, 1.0],
[1.0, 1.0, 1.0, 1.0],
[0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0],
[1.0, 1.0, 1.0, 1.0],
[0.0, 0.0, 0.0, 0.0],
]
]
).astype(np.float32)
image_shape = np.array([5, 5]).astype(np.int64)
block_shape = np.array([3, 3]).astype(np.int64)
y = col2im(x,image_shape,block_shape,strides=[2, 2])
y = np.array(y[0])
x = Tensor(Dtype.FP16x16, x.shape, to_fp(x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(y.flatten(), FixedImpl.FP16x16))
name = "col2im_strides"
func_sig = "NNTrait::col2im("
func_sig += "@input_0,"
func_sig += "array![5, 5].span(),"
func_sig += "array![3, 3].span(),"
func_sig += "Option::None,"
func_sig += "Option::None,"
func_sig += "Option::Some(array![2, 2].span()))"
make_test(
[x], y, func_sig, name, Trait.NN)
@staticmethod
def export_col2im_pads() -> None:
x = np.array(
[
[
[
1.0, 6.0, 11.0, 16.0, 21.0, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71,
], # (1, 5, 15)
[
2.0, 7.0, 12.0, 17.0, 22.0, 27, 32, 37, 42, 47, 52, 57, 62, 67, 72,
],
[
3.0, 8.0, 13.0, 18.0, 23.0, 28, 33, 38, 43, 48, 53, 58, 63, 68, 73,
],
[
4.0, 9.0, 14.0, 19.0, 24.0, 29, 34, 39, 44, 49, 54, 59, 64, 69, 74,
],
[
5.0, 10.0, 15.0, 20.0, 25.0, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75,
],
]
]
).astype(np.float32)
image_shape = np.array([5, 5]).astype(np.int64)
block_shape = np.array([1, 5]).astype(np.int64)
y = col2im(x,image_shape,block_shape,pads=[0, 1, 0, 1])
y = np.array(y[0])
x = Tensor(Dtype.FP16x16, x.shape, to_fp(x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(y.flatten(), FixedImpl.FP16x16))
name = "col2im_pads"
func_sig = "NNTrait::col2im("
func_sig += "@input_0,"
func_sig += "array![5, 5].span(),"
func_sig += "array![1, 5].span(),"
func_sig += "Option::None,"
func_sig += "Option::Some(array![0, 1, 0, 1].span()),"
func_sig += "Option::None)"
make_test(
[x], y, func_sig, name, Trait.NN)
@staticmethod
def export_col2im_dilations() -> None:
x = np.array(
[
[
[1.0, 5.0, 9.0, 13.0, 17], # (1, 4, 5)
[2.0, 6.0, 10.0, 14.0, 18],
[3.0, 7.0, 11.0, 15.0, 19],
[4.0, 8.0, 12.0, 16.0, 20],
]
]
).astype(np.float32)
image_shape = np.array([6, 6]).astype(np.int64)
block_shape = np.array([2, 2]).astype(np.int64)
y = col2im(x,image_shape,block_shape, dilations=[1, 5])
y = np.array(y[0])
x = Tensor(Dtype.FP16x16, x.shape, to_fp(x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(y.flatten(), FixedImpl.FP16x16))
name = "col2im_dilations"
func_sig = "NNTrait::col2im("
func_sig += "@input_0,"
func_sig += "array![6, 6].span(),"
func_sig += "array![2, 2].span(),"
func_sig += "Option::Some(array![1, 5].span()),"
func_sig += "Option::None,"
func_sig += "Option::None)"
make_test(
[x], y, func_sig, name, Trait.NN)
@staticmethod
def export_col2im_5D() -> None:
x = np.array(
[
[
[1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56], # (1, 10, 12)
[2, 7, 12, 17, 22, 27, 32, 37, 42, 47, 52, 57],
[3, 8, 13, 18, 23, 28, 33, 38, 43, 48, 53, 58],
[4, 9, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59],
[5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60],
[61, 66, 71, 76, 81, 86, 91, 96, 101, 106, 111, 116],
[62, 67, 72, 77, 82, 87, 92, 97, 102, 107, 112, 117],
[63, 68, 73, 78, 83, 88, 93, 98, 103, 108, 113, 118],
[64, 69, 74, 79, 84, 89, 94, 99, 104, 109, 114, 119],
[65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120],
]
]
).astype(np.float32)
image_shape = np.array([3, 4, 5]).astype(np.int64)
block_shape = np.array([1, 1, 5]).astype(np.int64)
y = col2im(x,image_shape,block_shape)
y = np.array(y[0])
x = Tensor(Dtype.FP16x16, x.shape, to_fp(x.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(y.flatten(), FixedImpl.FP16x16))
name = "col2im_5D"
func_sig = "NNTrait::col2im("
func_sig += "@input_0,"
func_sig += "array![3, 4, 5].span(),"
func_sig += "array![1, 1, 5].span(),"
func_sig += "Option::None,"
func_sig += "Option::None,"
func_sig += "Option::None)"
make_test(
[x], y, func_sig, name, Trait.NN)
| https://github.com/gizatechxyz/orion |
nodegen/node/compress.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl, Trait
class Compress(RunAll):
@staticmethod
def compress_fp16x16():
def compress_3D():
def default():
x1 = np.arange(0,27).reshape(3,3,3).astype(np.int64)
x2 = np.array([0, 1, 1]).astype(np.uint32)
y = x1.compress(x2, axis=0)
x1 = Tensor(Dtype.FP16x16, x1.shape, to_fp(x1.flatten(), FixedImpl.FP16x16))
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "compress_fp16x16_3d_default"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(0))",
name= name)
def axis1():
x1 = np.arange(0,180).reshape(3,4,3,5).astype(np.int64)
x2 = np.array([1, 1, 1, 0]).astype(np.int64)
y = x1.compress(x2, axis=1)
x1 = Tensor(Dtype.FP16x16, x1.shape, to_fp(x1.flatten(), FixedImpl.FP16x16))
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "compress_fp16x16_3d_axis1"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(1))",
name= name)
def axis2():
x1 = np.arange(0,48).reshape(4,3,4).astype(np.int64)
x2 = np.array([1, 0, 1, 1]).astype(np.int64)
y = x1.compress(x2, axis=2)
x1 = Tensor(Dtype.FP16x16, x1.shape, to_fp(x1.flatten(), FixedImpl.FP16x16))
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "compress_fp16x16_3d_axis2"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(2))",
name= name)
def axis3():
x1 = np.arange(0,96).reshape(4,3,4, 2).astype(np.int64)
x2 = np.array([1, 0]).astype(np.int64)
y = x1.compress(x2, axis=3)
x1 = Tensor(Dtype.FP16x16, x1.shape, to_fp(x1.flatten(), FixedImpl.FP16x16))
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "compress_fp16x16_3d_axis3"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(3))",
name= name)
def noaxis():
x1 = np.arange(0,27).reshape(3,3,3).astype(np.int64)
x2 = np.array([1, 0, 1, 0, 1, 1, 1, 1, 1]).astype(np.int64)
y = x1.compress(x2)
x1 = Tensor(Dtype.FP16x16, x1.shape, to_fp(x1.flatten(), FixedImpl.FP16x16))
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "compress_fp16x16_3d_noaxis"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::None(()))",
name= name)
default()
axis1()
axis2()
axis3()
noaxis()
compress_3D()
@staticmethod
def compress_fp8x23():
def compress_3D():
def default():
x1 = np.arange(0,27).reshape(3,3,3).astype(np.int64)
x2 = np.array([0, 1, 1]).astype(np.uint32)
y = x1.compress(x2, axis=0)
x1 = Tensor(Dtype.FP8x23, x1.shape, to_fp(x1.flatten(), FixedImpl.FP8x23))
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.FP8x23, y.shape, to_fp(y.flatten(), FixedImpl.FP8x23))
name = "compress_fp8x23_3d_default"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(0))",
name= name)
def axis1():
x1 = np.arange(0,27).reshape(3,3,3).astype(np.int64)
x2 = np.array([0, 1, 1]).astype(np.uint32)
y = x1.compress(x2, axis=1)
x1 = Tensor(Dtype.FP8x23, x1.shape, to_fp(x1.flatten(), FixedImpl.FP8x23))
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.FP8x23, y.shape, to_fp(y.flatten(), FixedImpl.FP8x23))
name = "compress_fp8x23_3d_axis1"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(1))",
name= name)
def axis2():
x1 = np.arange(0,27).reshape(3,3,3).astype(np.int64)
x2 = np.array([0, 1, 1]).astype(np.uint32)
y = x1.compress(x2, axis=2)
x1 = Tensor(Dtype.FP8x23, x1.shape, to_fp(x1.flatten(), FixedImpl.FP8x23))
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.FP8x23, y.shape, to_fp(y.flatten(), FixedImpl.FP8x23))
name = "compress_fp8x23_3d_axis2"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(2))",
name= name)
default()
axis1()
axis2()
compress_3D()
@staticmethod
def compress_i8():
def compress_3D():
def default():
x1 = np.arange(0,27).reshape(3,3,3).astype(np.int8)
x2 = np.array([0, 1, 1]).astype(np.uint8)
y = x1.compress(x2, axis=0)
x1 = Tensor(Dtype.I8, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.I8, y.shape, y.flatten())
name = "compress_i8_3d_default"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(0))",
name= name)
def axis1():
x1 = np.arange(0,27).reshape(3,3,3).astype(np.int8)
x2 = np.array([0, 1, 1]).astype(np.uint8)
y = x1.compress(x2, axis=1)
x1 = Tensor(Dtype.I8, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.I8, y.shape, y.flatten())
name = "compress_i8_3d_axis1"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(1))",
name= name)
def axis2():
x1 = np.arange(0,27).reshape(3,3,3).astype(np.int8)
x2 = np.array([0, 1, 1]).astype(np.uint8)
y = x1.compress(x2, axis=2)
x1 = Tensor(Dtype.I8, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.I8, y.shape, y.flatten())
name = "compress_i8_3d_axis2"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(2))",
name= name)
default()
axis1()
axis2()
compress_3D()
@staticmethod
def compress_i32():
def compress_3D():
def default():
x1 = np.arange(0,27).reshape(3,3,3).astype(np.int32)
x2 = np.array([0, 1, 1]).astype(np.int32)
y = x1.compress(x2, axis=0)
x1 = Tensor(Dtype.I32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
name = "compress_i32_3d_default"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(0))",
name= name)
def axis1():
x1 = np.arange(0,27).reshape(3,3,3).astype(np.int32)
x2 = np.array([0, 1, 1]).astype(np.int32)
y = x1.compress(x2, axis=1)
x1 = Tensor(Dtype.I32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
name = "compress_i32_3d_axis1"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(1))",
name= name)
def axis2():
x1 = np.arange(0,27).reshape(3,3,3).astype(np.int32)
x2 = np.array([0, 1, 1]).astype(np.int32)
y = x1.compress(x2, axis=2)
x1 = Tensor(Dtype.I32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
name = "compress_i32_3d_axis2"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(2))",
name= name)
default()
axis1()
axis2()
compress_3D()
@staticmethod
def compress_u32():
def compress_3D():
def default():
x1 = np.arange(0,48).reshape(4,4,3).astype(np.uint32)
x2 = np.array([1, 1]).astype(np.uint32)
y = x1.compress(x2, axis=0)
x1 = Tensor(Dtype.U32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "compress_u32_3d_default"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(0))",
name= name)
def axis1():
x1 = np.arange(0,36).reshape(3,4,3).astype(np.uint32)
x2 = np.array([0, 1, 1]).astype(np.uint32)
y = x1.compress(x2, axis=1)
x1 = Tensor(Dtype.U32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "compress_u32_3d_axis1"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(1))",
name= name)
def axis2():
x1 = np.arange(0,48).reshape(3,4,4).astype(np.uint32)
x2 = np.array([0, 1, 1]).astype(np.uint32)
y = x1.compress(x2, axis=2)
x1 = Tensor(Dtype.U32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "compress_u32_3d_axis2"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(2))",
name= name)
def axis2_2():
x1 = np.arange(0,60).reshape(3,4,5).astype(np.uint32)
x2 = np.array([0, 1, 1]).astype(np.uint32)
y = x1.compress(x2, axis=2)
x1 = Tensor(Dtype.U32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "compress_u32_3d_axis2_2"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(2))",
name= name)
def axis3():
x1 = np.arange(0,270).reshape(3,3,5,6).astype(np.uint32)
x2 = np.array([0, 1, 1,1,0,1]).astype(np.uint32)
y = x1.compress(x2, axis=3)
x1 = Tensor(Dtype.U32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "compress_u32_3d_axis3"
make_test(
inputs = [x1, x2], output = y, func_sig = "input_0.compress(condition:input_1, axis:Option::Some(3))",
name= name)
default()
axis1()
axis2()
axis2_2()
axis3()
compress_3D()
| https://github.com/gizatechxyz/orion |
nodegen/node/concat.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl, Trait
# 687
class Concat(RunAll):
@staticmethod
def concat_u32():
def concat_1D():
x1 = np.arange(0,3).astype(np.uint32)
x2 = np.arange(3,6).astype(np.uint32)
y = np.concatenate((x1, x2))
x1 = Tensor(Dtype.U32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "concat_u32_1d"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR)
def concat_2D():
x1 = np.arange(0,4).astype(np.uint32).reshape(2,2)
x2 = np.arange(4,8).astype(np.uint32).reshape(2,2)
y = np.concatenate((x1, x2), axis=0)
x1 = Tensor(Dtype.U32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "concat_u32_2d"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR)
def concat_3D():
def default():
x1 = np.arange(0,27).astype(np.uint32).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.uint32).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=0)
x1 = Tensor(Dtype.U32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "concat_u32_3d_default"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR)
def axis_1():
x1 = np.arange(0,27).astype(np.uint32).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.uint32).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=1)
x1 = Tensor(Dtype.U32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "concat_u32_3d_axis_1"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 1)",
name= name, trait= Trait.TENSOR)
def axis_2():
x1 = np.arange(0,27).astype(np.uint32).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.uint32).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=2)
x1 = Tensor(Dtype.U32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "concat_u32_3d_axis_2"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 2)",
name= name, trait= Trait.TENSOR)
def three_tensors_axis_1():
x1 = np.arange(0,27).astype(np.uint32).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.uint32).reshape(3,3,3)
x3 = np.arange(54,81).astype(np.uint32).reshape(3,3,3)
y = np.concatenate((x1, x2, x3), axis=1)
x1 = Tensor(Dtype.U32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
x3 = Tensor(Dtype.U32, x3.shape, x3.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "concat_u32_3d_three_tensors_axis_1"
make_test(
inputs = [x1, x2, x3], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1, input_2].span(), 1)",
name= name, trait= Trait.TENSOR)
def three_tensors_axis_2():
x1 = np.arange(0,27).astype(np.uint32).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.uint32).reshape(3,3,3)
x3 = np.arange(54,81).astype(np.uint32).reshape(3,3,3)
y = np.concatenate((x1, x2, x3), axis=2)
x1 = Tensor(Dtype.U32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.U32, x2.shape, x2.flatten())
x3 = Tensor(Dtype.U32, x3.shape, x3.flatten())
y = Tensor(Dtype.U32, y.shape, y.flatten())
name = "concat_u32_3d_three_tensors_axis_2"
make_test(
inputs = [x1, x2, x3], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1, input_2].span(), 2)",
name= name, trait= Trait.TENSOR)
default()
axis_1()
axis_2()
three_tensors_axis_1()
three_tensors_axis_2()
concat_1D()
concat_2D()
concat_3D()
@staticmethod
def concat_i32():
def concat_1D():
x1 = np.arange(0,3).astype(np.int32)
x2 = np.arange(3,6).astype(np.int32)
y = np.concatenate((x1, x2))
x1 = Tensor(Dtype.I32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.I32, x2.shape, x2.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
name = "concat_i32_1d"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR.TENSOR)
def concat_2D():
x1 = np.arange(0,4).astype(np.int32).reshape(2,2)
x2 = np.arange(4,8).astype(np.int32).reshape(2,2)
y = np.concatenate((x1, x2), axis=0)
x1 = Tensor(Dtype.I32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.I32, x2.shape, x2.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
name = "concat_i32_2d"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR)
def concat_3D():
def default():
x1 = np.arange(0,27).astype(np.int32).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int32).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=0)
x1 = Tensor(Dtype.I32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.I32, x2.shape, x2.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
name = "concat_i32_3d_default"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR)
def axis_1():
x1 = np.arange(0,27).astype(np.int32).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int32).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=1)
x1 = Tensor(Dtype.I32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.I32, x2.shape, x2.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
name = "concat_i32_3d_axis_1"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 1)",
name= name, trait= Trait.TENSOR)
def axis_2():
x1 = np.arange(0,27).astype(np.int32).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int32).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=2)
x1 = Tensor(Dtype.I32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.I32, x2.shape, x2.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
name = "concat_i32_3d_axis_2"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 2)",
name= name, trait= Trait.TENSOR)
def three_tensors_axis_1():
x1 = np.arange(0,27).astype(np.int32).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int32).reshape(3,3,3)
x3 = np.arange(54,81).astype(np.int32).reshape(3,3,3)
y = np.concatenate((x1, x2, x3), axis=1)
x1 = Tensor(Dtype.I32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.I32, x2.shape, x2.flatten())
x3 = Tensor(Dtype.I32, x3.shape, x3.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
name = "concat_i32_3d_three_tensors_axis_1"
make_test(
inputs = [x1, x2, x3], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1, input_2].span(), 1)",
name= name, trait= Trait.TENSOR)
def three_tensors_axis_2():
x1 = np.arange(0,27).astype(np.int32).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int32).reshape(3,3,3)
x3 = np.arange(54,81).astype(np.int32).reshape(3,3,3)
y = np.concatenate((x1, x2, x3), axis=2)
x1 = Tensor(Dtype.I32, x1.shape, x1.flatten())
x2 = Tensor(Dtype.I32, x2.shape, x2.flatten())
x3 = Tensor(Dtype.I32, x3.shape, x3.flatten())
y = Tensor(Dtype.I32, y.shape, y.flatten())
name = "concat_i32_3d_three_tensors_axis_2"
make_test(
inputs = [x1, x2, x3], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1, input_2].span(), 2)",
name= name, trait= Trait.TENSOR)
default()
axis_1()
axis_2()
three_tensors_axis_1()
three_tensors_axis_2()
concat_1D()
concat_2D()
concat_3D()
@staticmethod
def concat_i8():
def concat_1D():
x1 = np.arange(0,3).astype(np.int8)
x2 = np.arange(3,6).astype(np.int8)
y = np.concatenate((x1, x2))
x1 = Tensor(Dtype.FP8x23, x1.shape, x1.flatten())
x2 = Tensor(Dtype.FP8x23, x2.shape, x2.flatten())
y = Tensor(Dtype.FP8x23, y.shape, y.flatten())
name = "concat_i8_1d"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR.TENSOR)
def concat_2D():
x1 = np.arange(0,4).astype(np.int8).reshape(2,2)
x2 = np.arange(4,8).astype(np.int8).reshape(2,2)
y = np.concatenate((x1, x2), axis=0)
x1 = Tensor(Dtype.FP8x23, x1.shape, x1.flatten())
x2 = Tensor(Dtype.FP8x23, x2.shape, x2.flatten())
y = Tensor(Dtype.FP8x23, y.shape, y.flatten())
name = "concat_i8_2d"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR)
def concat_3D():
def default():
x1 = np.arange(0,27).astype(np.int8).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int8).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=0)
x1 = Tensor(Dtype.FP8x23, x1.shape, x1.flatten())
x2 = Tensor(Dtype.FP8x23, x2.shape, x2.flatten())
y = Tensor(Dtype.FP8x23, y.shape, y.flatten())
name = "concat_i8_3d_default"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR)
def axis_1():
x1 = np.arange(0,27).astype(np.int8).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int8).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=1)
x1 = Tensor(Dtype.FP8x23, x1.shape, x1.flatten())
x2 = Tensor(Dtype.FP8x23, x2.shape, x2.flatten())
y = Tensor(Dtype.FP8x23, y.shape, y.flatten())
name = "concat_i8_3d_axis_1"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 1)",
name= name, trait= Trait.TENSOR)
def axis_2():
x1 = np.arange(0,27).astype(np.int8).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int8).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=2)
x1 = Tensor(Dtype.FP8x23, x1.shape, x1.flatten())
x2 = Tensor(Dtype.FP8x23, x2.shape, x2.flatten())
y = Tensor(Dtype.FP8x23, y.shape, y.flatten())
name = "concat_i8_3d_axis_2"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 2)",
name= name, trait= Trait.TENSOR)
def three_tensors_axis_1():
x1 = np.arange(0,27).astype(np.int8).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int8).reshape(3,3,3)
x3 = np.arange(54,81).astype(np.int8).reshape(3,3,3)
y = np.concatenate((x1, x2, x3), axis=1)
x1 = Tensor(Dtype.FP8x23, x1.shape, x1.flatten())
x2 = Tensor(Dtype.FP8x23, x2.shape, x2.flatten())
x3 = Tensor(Dtype.FP8x23, x3.shape, x3.flatten())
y = Tensor(Dtype.FP8x23, y.shape, y.flatten())
name = "concat_i8_3d_three_tensors_axis_1"
make_test(
inputs = [x1, x2, x3], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1, input_2].span(), 1)",
name= name, trait= Trait.TENSOR)
def three_tensors_axis_2():
x1 = np.arange(0,27).astype(np.int8).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int8).reshape(3,3,3)
x3 = np.arange(54,81).astype(np.int8).reshape(3,3,3)
y = np.concatenate((x1, x2, x3), axis=2)
x1 = Tensor(Dtype.FP8x23, x1.shape, x1.flatten())
x2 = Tensor(Dtype.FP8x23, x2.shape, x2.flatten())
x3 = Tensor(Dtype.FP8x23, x3.shape, x3.flatten())
y = Tensor(Dtype.FP8x23, y.shape, y.flatten())
name = "concat_i8_3d_three_tensors_axis_2"
make_test(
inputs = [x1, x2, x3], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1, input_2].span(), 2)",
name= name, trait= Trait.TENSOR)
default()
axis_1()
axis_2()
three_tensors_axis_1()
three_tensors_axis_2()
concat_1D()
concat_2D()
concat_3D()
@staticmethod
def concat_fp8x23():
def concat_1D():
x1 = np.arange(0,3).astype(np.int64)
x2 = np.arange(3,6).astype(np.int64)
y = np.concatenate((x1, x2))
x1 = Tensor(Dtype.FP8x23, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP8x23))
x2 = Tensor(Dtype.FP8x23, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(
y.flatten(), FixedImpl.FP8x23))
name = "concat_fp8x23_1d"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR.TENSOR)
def concat_2D():
x1 = np.arange(0,4).astype(np.int64).reshape(2,2)
x2 = np.arange(4,8).astype(np.int64).reshape(2,2)
y = np.concatenate((x1, x2), axis=0)
x1 = Tensor(Dtype.FP8x23, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP8x23))
x2 = Tensor(Dtype.FP8x23, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(
y.flatten(), FixedImpl.FP8x23))
name = "concat_fp8x23_2d"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR)
def concat_3D():
def default():
x1 = np.arange(0,27).astype(np.int64).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int64).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=0)
x1 = Tensor(Dtype.FP8x23, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP8x23))
x2 = Tensor(Dtype.FP8x23, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape,to_fp(
y.flatten(), FixedImpl.FP8x23))
name = "concat_fp8x23_3d_default"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR)
def axis_1():
x1 = np.arange(0,27).astype(np.int64).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int64).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=1)
x1 = Tensor(Dtype.FP8x23, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP8x23))
x2 = Tensor(Dtype.FP8x23, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(
y.flatten(), FixedImpl.FP8x23))
name = "concat_fp8x23_3d_axis_1"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 1)",
name= name, trait= Trait.TENSOR)
def axis_2():
x1 = np.arange(0,27).astype(np.int64).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int64).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=2)
x1 = Tensor(Dtype.FP8x23, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP8x23))
x2 = Tensor(Dtype.FP8x23, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(
y.flatten(), FixedImpl.FP8x23))
name = "concat_fp8x23_3d_axis_2"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 2)",
name= name, trait= Trait.TENSOR)
def three_tensors_axis_1():
x1 = np.arange(0,27).astype(np.int64).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int64).reshape(3,3,3)
x3 = np.arange(54,81).astype(np.int64).reshape(3,3,3)
y = np.concatenate((x1, x2, x3), axis=1)
x1 = Tensor(Dtype.FP8x23, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP8x23))
x2 = Tensor(Dtype.FP8x23, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP8x23))
x3 = Tensor(Dtype.FP8x23, x3.shape,to_fp(
x3.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(
y.flatten(), FixedImpl.FP8x23))
name = "concat_fp8x23_3d_three_tensors_axis_1"
make_test(
inputs = [x1, x2, x3], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1, input_2].span(), 1)",
name= name, trait= Trait.TENSOR)
def three_tensors_axis_2():
x1 = np.arange(0,27).astype(np.int64).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int64).reshape(3,3,3)
x3 = np.arange(54,81).astype(np.int64).reshape(3,3,3)
y = np.concatenate((x1, x2, x3), axis=2)
x1 = Tensor(Dtype.FP8x23, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP8x23))
x2 = Tensor(Dtype.FP8x23, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP8x23))
x3 = Tensor(Dtype.FP8x23, x3.shape, to_fp(
x3.flatten(), FixedImpl.FP8x23))
y = Tensor(Dtype.FP8x23, y.shape, to_fp(
y.flatten(), FixedImpl.FP8x23))
name = "concat_fp8x23_3d_three_tensors_axis_2"
make_test(
inputs = [x1, x2, x3], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1, input_2].span(), 2)",
name= name, trait= Trait.TENSOR)
default()
axis_1()
axis_2()
three_tensors_axis_1()
three_tensors_axis_2()
concat_1D()
concat_2D()
concat_3D()
staticmethod
def concat_fp16x16():
def concat_1D():
x1 = np.arange(0,3).astype(np.int64)
x2 = np.arange(3,6).astype(np.int64)
y = np.concatenate((x1, x2))
x1 = Tensor(Dtype.FP16x16, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP16x16))
x2 = Tensor(Dtype.FP16x16, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "concat_fp16x16_1d"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR.TENSOR)
def concat_2D():
x1 = np.arange(0,4).astype(np.int64).reshape(2,2)
x2 = np.arange(4,8).astype(np.int64).reshape(2,2)
y = np.concatenate((x1, x2), axis=0)
x1 = Tensor(Dtype.FP16x16, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP16x16))
x2 = Tensor(Dtype.FP16x16, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "concat_fp16x16_2d"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR)
def concat_3D():
def default():
x1 = np.arange(0,27).astype(np.int64).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int64).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=0)
x1 = Tensor(Dtype.FP16x16, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP16x16))
x2 = Tensor(Dtype.FP16x16, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "concat_fp16x16_3d_default"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 0)",
name= name, trait= Trait.TENSOR)
def axis_1():
x1 = np.arange(0,27).astype(np.int64).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int64).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=1)
x1 = Tensor(Dtype.FP16x16, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP16x16))
x2 = Tensor(Dtype.FP16x16, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape ,to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "concat_fp16x16_3d_axis_1"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 1)",
name= name, trait= Trait.TENSOR)
def axis_2():
x1 = np.arange(0,27).astype(np.int64).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int64).reshape(3,3,3)
y = np.concatenate((x1, x2), axis=2)
x1 = Tensor(Dtype.FP16x16, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP16x16))
x2 = Tensor(Dtype.FP16x16, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "concat_fp16x16_3d_axis_2"
make_test(
inputs = [x1, x2], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1].span(), 2)",
name= name, trait= Trait.TENSOR)
def three_tensors_axis_1():
x1 = np.arange(0,27).astype(np.int64).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int64).reshape(3,3,3)
x3 = np.arange(54,81).astype(np.int64).reshape(3,3,3)
y = np.concatenate((x1, x2, x3), axis=1)
x1 = Tensor(Dtype.FP16x16, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP16x16))
x2 = Tensor(Dtype.FP16x16, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP16x16))
x3 = Tensor(Dtype.FP16x16, x3.shape, to_fp(
x3.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape, to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "concat_fp16x16_3d_three_tensors_axis_1"
make_test(
inputs = [x1, x2, x3], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1, input_2].span(), 1)",
name= name, trait= Trait.TENSOR)
def three_tensors_axis_2():
x1 = np.arange(0,27).astype(np.int64).reshape(3,3,3)
x2 = np.arange(27,54).astype(np.int64).reshape(3,3,3)
x3 = np.arange(54,81).astype(np.int64).reshape(3,3,3)
y = np.concatenate((x1, x2, x3), axis=2)
x1 = Tensor(Dtype.FP16x16, x1.shape, to_fp(
x1.flatten(), FixedImpl.FP16x16))
x2 = Tensor(Dtype.FP16x16, x2.shape, to_fp(
x2.flatten(), FixedImpl.FP16x16))
x3 = Tensor(Dtype.FP16x16, x3.shape, to_fp(
x3.flatten(), FixedImpl.FP16x16))
y = Tensor(Dtype.FP16x16, y.shape,to_fp(
y.flatten(), FixedImpl.FP16x16))
name = "concat_fp16x16_3d_three_tensors_axis_2"
make_test(
inputs = [x1, x2, x3], output = y, func_sig = "TensorTrait::concat(array![input_0, input_1, input_2].span(), 2)",
name= name, trait= Trait.TENSOR)
default()
axis_1()
axis_2()
three_tensors_axis_1()
three_tensors_axis_2()
concat_1D()
concat_2D()
concat_3D()
| https://github.com/gizatechxyz/orion |
nodegen/node/concat_from_sequence.py | import numpy as np
from nodegen.node import RunAll
from ..helpers import make_test, to_fp, Tensor, Dtype, FixedImpl, Trait
class Concat_from_sequence(RunAll):
@staticmethod
def concat_from_sequence_u32():
def new_axis_zero():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
values = np.random.randint(0, 6, shape).astype(np.uint32)
tensor = Tensor(Dtype.U32, values.shape, values.flatten())
sequence.append(tensor)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(0)
concatenated_tensor = np.concatenate(values_array, axis)
concatenated_tensor = Tensor(Dtype.U32, concatenated_tensor.shape, concatenated_tensor.flatten())
name = "concat_from_sequence_u32_new_axis_zero"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::Some(0))", name, Trait.SEQUENCE)
def new_axis_one():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
values = np.random.randint(0, 6, shape).astype(np.uint32)
tensor = Tensor(Dtype.U32, values.shape, values.flatten())
sequence.append(tensor)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(1)
concatenated_tensor = np.stack(values_array, axis)
concatenated_tensor = Tensor(Dtype.U32, concatenated_tensor.shape, concatenated_tensor.flatten())
name = "concat_from_sequence_u32_new_axis_one"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::Some(1))", name, Trait.SEQUENCE)
def new_axis_default():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
values = np.random.randint(0, 6, shape).astype(np.uint32)
tensor = Tensor(Dtype.U32, values.shape, values.flatten())
sequence.append(tensor)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(0)
concatenated_tensor = np.concatenate(values_array, axis)
concatenated_tensor = Tensor(Dtype.U32, concatenated_tensor.shape, concatenated_tensor.flatten())
name = "concat_from_sequence_u32_new_axis_default"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::None(()))", name, Trait.SEQUENCE)
new_axis_zero()
new_axis_one()
new_axis_default()
@staticmethod
def concat_from_sequence_i32():
def new_axis_zero():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
values = np.random.randint(-6, 6, shape).astype(np.int32)
tensor = Tensor(Dtype.I32, values.shape, values.flatten())
sequence.append(tensor)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(0)
concatenated_tensor = np.concatenate(values_array, axis)
concatenated_tensor = Tensor(Dtype.I32, concatenated_tensor.shape, concatenated_tensor.flatten())
name = "concat_from_sequence_i32_new_axis_zero"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::Some(0))", name, Trait.SEQUENCE)
def new_axis_one():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
values = np.random.randint(-6, 6, shape).astype(np.int32)
tensor = Tensor(Dtype.I32, values.shape, values.flatten())
sequence.append(tensor)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(1)
concatenated_tensor = np.stack(values_array, axis)
concatenated_tensor = Tensor(Dtype.I32, concatenated_tensor.shape, concatenated_tensor.flatten())
name = "concat_from_sequence_i32_new_axis_one"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::Some(1))", name, Trait.SEQUENCE)
def new_axis_default():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
values = np.random.randint(-6, 6, shape).astype(np.int32)
tensor = Tensor(Dtype.I32, values.shape, values.flatten())
sequence.append(tensor)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(0)
concatenated_tensor = np.concatenate(values_array, axis)
concatenated_tensor = Tensor(Dtype.I32, concatenated_tensor.shape, concatenated_tensor.flatten())
name = "concat_from_sequence_i32_new_axis_default"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::None(()))", name, Trait.SEQUENCE)
new_axis_zero()
new_axis_one()
new_axis_default()
@staticmethod
def concat_from_sequence_i8():
def new_axis_zero():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
values = np.random.randint(-6, 6, shape).astype(np.int8)
tensor = Tensor(Dtype.I8, values.shape, values.flatten())
sequence.append(tensor)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(0)
concatenated_tensor = np.concatenate(values_array, axis)
concatenated_tensor = Tensor(Dtype.I8, concatenated_tensor.shape, concatenated_tensor.flatten())
name = "concat_from_sequence_i8_new_axis_zero"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::Some(0))", name, Trait.SEQUENCE)
def new_axis_one():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
values = np.random.randint(-6, 6, shape).astype(np.int8)
tensor = Tensor(Dtype.I8, values.shape, values.flatten())
sequence.append(tensor)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(1)
concatenated_tensor = np.stack(values_array, axis)
concatenated_tensor = Tensor(Dtype.I8, concatenated_tensor.shape, concatenated_tensor.flatten())
name = "concat_from_sequence_i8_new_axis_one"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::Some(1))", name, Trait.SEQUENCE)
def new_axis_default():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
values = np.random.randint(-6, 6, shape).astype(np.int8)
tensor = Tensor(Dtype.I8, values.shape, values.flatten())
sequence.append(tensor)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(0)
concatenated_tensor = np.concatenate(values_array, axis)
concatenated_tensor = Tensor(Dtype.I8, concatenated_tensor.shape, concatenated_tensor.flatten())
name = "concat_from_sequence_i8_new_axis_default"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::None(()))", name, Trait.SEQUENCE)
new_axis_zero()
new_axis_one()
new_axis_default()
@staticmethod
def concat_from_sequence_fp8x23():
def new_axis_zero():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
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)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(0)
concatenated_tensor = np.concatenate(values_array, axis)
concatenated_tensor = Tensor(Dtype.FP8x23, concatenated_tensor.shape, to_fp(concatenated_tensor.flatten(), FixedImpl.FP8x23))
name = "concat_from_sequence_fp8x23_new_axis_zero"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::Some(0))", name, Trait.SEQUENCE)
def new_axis_one():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
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)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(1)
concatenated_tensor = np.stack(values_array, axis)
concatenated_tensor = Tensor(Dtype.FP8x23, concatenated_tensor.shape, to_fp(concatenated_tensor.flatten(), FixedImpl.FP8x23))
name = "concat_from_sequence_fp8x23_new_axis_one"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::Some(1))", name, Trait.SEQUENCE)
def new_axis_default():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
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)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(0)
concatenated_tensor = np.concatenate(values_array, axis)
concatenated_tensor = Tensor(Dtype.FP8x23, concatenated_tensor.shape, to_fp(concatenated_tensor.flatten(), FixedImpl.FP8x23))
name = "concat_from_sequence_fp8x23_new_axis_default"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::None(()))", name, Trait.SEQUENCE)
new_axis_zero()
new_axis_one()
new_axis_default()
@staticmethod
def concat_from_sequence_fp16x16():
def new_axis_zero():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
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)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(0)
concatenated_tensor = np.concatenate(values_array, axis)
concatenated_tensor = Tensor(Dtype.FP16x16, concatenated_tensor.shape, to_fp(concatenated_tensor.flatten(), FixedImpl.FP16x16))
name = "concat_from_sequence_fp16x16_new_axis_zero"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::Some(0))", name, Trait.SEQUENCE)
def new_axis_one():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
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)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(1)
concatenated_tensor = np.stack(values_array, axis)
concatenated_tensor = Tensor(Dtype.FP16x16, concatenated_tensor.shape, to_fp(concatenated_tensor.flatten(), FixedImpl.FP16x16))
name = "concat_from_sequence_fp16x16_new_axis_one"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::Some(1))", name, Trait.SEQUENCE)
def new_axis_default():
sequence = []
values_array = []
shape = np.random.randint(1, 4, 2)
for _ in range(5):
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)
values_array.append(values)
axis = np.int32(1)
new_axis = np.uint32(0)
concatenated_tensor = np.concatenate(values_array, axis)
concatenated_tensor = Tensor(Dtype.FP16x16, concatenated_tensor.shape, to_fp(concatenated_tensor.flatten(), FixedImpl.FP16x16))
name = "concat_from_sequence_fp16x16_new_axis_default"
make_test([sequence], concatenated_tensor, "SequenceTrait::concat_from_sequence(input_0, 1_i32, Option::None(()))", name, Trait.SEQUENCE)
new_axis_zero()
new_axis_one()
new_axis_default() | https://github.com/gizatechxyz/orion |
End of preview. Expand
in Dataset Viewer.
This dataset contains the code from all the ZKML repos that I'm aware of that have an MIT, Apache or GPL 3.0 license. It only contains the files with extensions: ".py", ".js", ".java", ".c", ".cpp", ".h", ".hpp", ".rs", "cairo", ".zkey", ".sol", ".circom", ".ejs", ".ipynb" List of repos: "https://github.com/gizatechxyz/orion", "https://github.com/gizatechxyz/Giza-Hub", "https://github.com/zkonduit/ezkl", "https://github.com/socathie/keras2circom", "https://github.com/socathie/circomlib-ml" "https://github.com/worldcoin/proto-neural-zkp", "https://github.com/Modulus-Labs/RockyBot" "https://github.com/ora-io/keras2circom", "https://github.com/zk-ml/tachikoma", "https://github.com/only4sim/ZK-DTP", "https://github.com/ddkang/zkml", "https://github.com/socathie/ZKaggleV2"
- Downloads last month
- 40