module concrete.ml.common

Module for shared data structures and code.

Global Variables

• debugging

• check_inputs

• utils

API Overview

Modules

• concrete.ml.common: Module for shared data structures and code.

• concrete.ml.common.check_inputs: Check and conversion tools.

• concrete.ml.common.debugging: Module for debugging.

• concrete.ml.common.debugging.custom_assert: Provide some variants of assert.

• concrete.ml.common.utils: Utils that can be re-used by other pieces of code in the module.

• concrete.ml.deployment: Module for deployment of the FHE model.

• concrete.ml.deployment.fhe_client_server: APIs for FHE deployment.

• concrete.ml.onnx: ONNX module.

• concrete.ml.onnx.convert: ONNX conversion related code.

• concrete.ml.onnx.onnx_impl_utils: Utility functions for onnx operator implementations.

• concrete.ml.onnx.onnx_model_manipulations: Some code to manipulate models.

• concrete.ml.onnx.onnx_utils: Utils to interpret an ONNX model with numpy.

• concrete.ml.onnx.ops_impl: ONNX ops implementation in python + numpy.

• concrete.ml.quantization: Modules for quantization.

• concrete.ml.quantization.base_quantized_op: Base Quantized Op class that implements quantization for a float numpy op.

• concrete.ml.quantization.post_training: Post Training Quantization methods.

• concrete.ml.quantization.quantized_module: QuantizedModule API.

• concrete.ml.quantization.quantized_ops: Quantized versions of the ONNX operators for post training quantization.

• concrete.ml.quantization.quantizers: Quantization utilities for a numpy array/tensor.

• concrete.ml.sklearn: Import sklearn models.

• concrete.ml.sklearn.base: Module that contains base classes for our libraries estimators.

• concrete.ml.sklearn.glm: Implement sklearn's Generalized Linear Models (GLM).

• concrete.ml.sklearn.linear_model: Implement sklearn linear model.

• concrete.ml.sklearn.protocols: Protocols.

• concrete.ml.sklearn.qnn: Scikit-learn interface for concrete quantized neural networks.

• concrete.ml.sklearn.rf: Implements RandomForest models.

• concrete.ml.sklearn.svm: Implement Support Vector Machine.

• concrete.ml.sklearn.torch_module: Implement torch module.

• concrete.ml.sklearn.tree: Implement the sklearn tree models.

• concrete.ml.sklearn.tree_to_numpy: Implements the conversion of a tree model to a numpy function.

• concrete.ml.sklearn.xgb: Implements XGBoost models.

• concrete.ml.torch: Modules for torch to numpy conversion.

• concrete.ml.torch.compile: torch compilation function.

• concrete.ml.torch.numpy_module: A torch to numpy module.

• concrete.ml.version: File to manage the version of the package.

Classes

• fhe_client_server.FHEModelClient: Client API to encrypt and decrypt FHE data.

• fhe_client_server.FHEModelDev: Dev API to save the model and then load and run the FHE circuit.

• fhe_client_server.FHEModelServer: Server API to load and run the FHE circuit.

• ops_impl.ONNXMixedFunction: A mixed quantized-raw valued onnx function.

• base_quantized_op.QuantizedOp: Base class for quantized ONNX ops implemented in numpy.

• base_quantized_op.QuantizedOpUnivariateOfEncrypted: An univariate operator of an encrypted value.

• post_training.ONNXConverter: Base ONNX to Concrete ML computation graph conversion class.

• post_training.PostTrainingAffineQuantization: Post-training Affine Quantization.

• post_training.PostTrainingQATImporter: Converter of Quantization Aware Training networks.

• quantized_module.QuantizedModule: Inference for a quantized model.

• quantized_ops.QuantizedAbs: Quantized Abs op.

• quantized_ops.QuantizedAdd: Quantized Addition operator.

• quantized_ops.QuantizedAvgPool: Quantized Average Pooling op.

• quantized_ops.QuantizedBatchNormalization: Quantized Batch normalization with encrypted input and in-the-clear normalization params.

• quantized_ops.QuantizedBrevitasQuant: Brevitas uniform quantization with encrypted input.

• quantized_ops.QuantizedCast: Cast the input to the required data type.

• quantized_ops.QuantizedCelu: Quantized Celu op.

• quantized_ops.QuantizedClip: Quantized clip op.

• quantized_ops.QuantizedConv: Quantized Conv op.

• quantized_ops.QuantizedDiv: Div operator /.

• quantized_ops.QuantizedElu: Quantized Elu op.

• quantized_ops.QuantizedErf: Quantized erf op.

• quantized_ops.QuantizedExp: Quantized Exp op.

• quantized_ops.QuantizedFlatten: Quantized flatten for encrypted inputs.

• quantized_ops.QuantizedFloor: Quantized Floor op.

• quantized_ops.QuantizedGemm: Quantized Gemm op.

• quantized_ops.QuantizedGreater: Comparison operator >.

• quantized_ops.QuantizedGreaterOrEqual: Comparison operator >=.

• quantized_ops.QuantizedHardSigmoid: Quantized HardSigmoid op.

• quantized_ops.QuantizedHardSwish: Quantized Hardswish op.

• quantized_ops.QuantizedIdentity: Quantized Identity op.

• quantized_ops.QuantizedLeakyRelu: Quantized LeakyRelu op.

• quantized_ops.QuantizedLess: Comparison operator <.

• quantized_ops.QuantizedLessOrEqual: Comparison operator <=.

• quantized_ops.QuantizedLog: Quantized Log op.

• quantized_ops.QuantizedMatMul: Quantized MatMul op.

• quantized_ops.QuantizedMax: Quantized Max op.

• quantized_ops.QuantizedMin: Quantized Min op.

• quantized_ops.QuantizedMul: Multiplication operator.

• quantized_ops.QuantizedNeg: Quantized Neg op.

• quantized_ops.QuantizedNot: Quantized Not op.

• quantized_ops.QuantizedOr: Or operator ||.

• quantized_ops.QuantizedPRelu: Quantized PRelu op.

• quantized_ops.QuantizedPad: Quantized Padding op.

• quantized_ops.QuantizedPow: Quantized pow op.

• quantized_ops.QuantizedReduceSum: ReduceSum with encrypted input.

• quantized_ops.QuantizedRelu: Quantized Relu op.

• quantized_ops.QuantizedReshape: Quantized Reshape op.

• quantized_ops.QuantizedRound: Quantized round op.

• quantized_ops.QuantizedSelu: Quantized Selu op.

• quantized_ops.QuantizedSigmoid: Quantized sigmoid op.

• quantized_ops.QuantizedSign: Quantized Neg op.

• quantized_ops.QuantizedSoftplus: Quantized Softplus op.

• quantized_ops.QuantizedSub: Subtraction operator.

• quantized_ops.QuantizedTanh: Quantized Tanh op.

• quantized_ops.QuantizedTranspose: Transpose operator for quantized inputs.

• quantized_ops.QuantizedWhere: Where operator on quantized arrays.

• quantizers.MinMaxQuantizationStats: Calibration set statistics.

• quantizers.QuantizationOptions: Options for quantization.

• quantizers.QuantizedArray: Abstraction of quantized array.

• quantizers.UniformQuantizationParameters: Quantization parameters for uniform quantization.

• quantizers.UniformQuantizer: Uniform quantizer.

• base.BaseTreeClassifierMixin: Mixin class for tree-based classifiers.

• base.BaseTreeEstimatorMixin: Mixin class for tree-based estimators.

• base.BaseTreeRegressorMixin: Mixin class for tree-based regressors.

• base.QuantizedTorchEstimatorMixin: Mixin that provides quantization for a torch module and follows the Estimator API.

• base.SklearnLinearClassifierMixin: A Mixin class for sklearn linear classifiers with FHE.

• base.SklearnLinearModelMixin: A Mixin class for sklearn linear models with FHE.

• glm.GammaRegressor: A Gamma regression model with FHE.

• glm.PoissonRegressor: A Poisson regression model with FHE.

• glm.TweedieRegressor: A Tweedie regression model with FHE.

• linear_model.ElasticNet: An ElasticNet regression model with FHE.

• linear_model.Lasso: A Lasso regression model with FHE.

• linear_model.LinearRegression: A linear regression model with FHE.

• linear_model.LogisticRegression: A logistic regression model with FHE.

• linear_model.Ridge: A Ridge regression model with FHE.

• protocols.ConcreteBaseClassifierProtocol: Concrete classifier protocol.

• protocols.ConcreteBaseEstimatorProtocol: A Concrete Estimator Protocol.

• protocols.ConcreteBaseRegressorProtocol: Concrete regressor protocol.

• protocols.Quantizer: Quantizer Protocol.

• qnn.FixedTypeSkorchNeuralNet: A mixin with a helpful modification to a skorch estimator that fixes the module type.

• qnn.NeuralNetClassifier: Scikit-learn interface for quantized FHE compatible neural networks.

• qnn.NeuralNetRegressor: Scikit-learn interface for quantized FHE compatible neural networks.

• qnn.QuantizedSkorchEstimatorMixin: Mixin class that adds quantization features to Skorch NN estimators.

• qnn.SparseQuantNeuralNetImpl: Sparse Quantized Neural Network classifier.

• rf.RandomForestClassifier: Implements the RandomForest classifier.

• rf.RandomForestRegressor: Implements the RandomForest regressor.

• svm.LinearSVC: A Classification Support Vector Machine (SVM).

• svm.LinearSVR: A Regression Support Vector Machine (SVM).

• tree.DecisionTreeClassifier: Implements the sklearn DecisionTreeClassifier.

• tree.DecisionTreeRegressor: Implements the sklearn DecisionTreeClassifier.

• tree_to_numpy.Task: Task enumerate.

• xgb.XGBClassifier: Implements the XGBoost classifier.

• xgb.XGBRegressor: Implements the XGBoost regressor.

• numpy_module.NumpyModule: General interface to transform a torch.nn.Module to numpy module.

Functions

• check_inputs.check_X_y_and_assert: sklearn.utils.check_X_y with an assert.

• check_inputs.check_array_and_assert: sklearn.utils.check_array with an assert.

• custom_assert.assert_false: Provide a custom assert to check that the condition is False.

• custom_assert.assert_not_reached: Provide a custom assert to check that a piece of code is never reached.

• custom_assert.assert_true: Provide a custom assert to check that the condition is True.

• utils.generate_proxy_function: Generate a proxy function for a function accepting only *args type arguments.

• utils.get_onnx_opset_version: Return the ONNX opset_version.

• utils.replace_invalid_arg_name_chars: Sanitize arg_name, replacing invalid chars by _.

• convert.get_equivalent_numpy_forward: Get the numpy equivalent forward of the provided ONNX model.

• convert.get_equivalent_numpy_forward_and_onnx_model: Get the numpy equivalent forward of the provided torch Module.

• onnx_impl_utils.compute_conv_output_dims: Compute the output shape of a pool or conv operation.

• onnx_impl_utils.compute_onnx_pool_padding: Compute any additional padding needed to compute pooling layers.

• onnx_impl_utils.numpy_onnx_pad: Pad a tensor according to ONNX spec, using an optional custom pad value.

• onnx_impl_utils.onnx_avgpool_compute_norm_const: Compute the average pooling normalization constant.

• onnx_model_manipulations.clean_graph_after_node_name: Clean the graph of the onnx model by removing nodes after the given node name.

• onnx_model_manipulations.clean_graph_after_node_op_type: Clean the graph of the onnx model by removing nodes after the given node type.

• onnx_model_manipulations.keep_following_outputs_discard_others: Keep the outputs given in outputs_to_keep and remove the others from the model.

• onnx_model_manipulations.remove_identity_nodes: Remove identity nodes from a model.

• onnx_model_manipulations.remove_node_types: Remove unnecessary nodes from the ONNX graph.

• onnx_model_manipulations.remove_unused_constant_nodes: Remove unused Constant nodes in the provided onnx model.

• onnx_model_manipulations.simplify_onnx_model: Simplify an ONNX model, removes unused Constant nodes and Identity nodes.

• onnx_utils.execute_onnx_with_numpy: Execute the provided ONNX graph on the given inputs.

• onnx_utils.get_attribute: Get the attribute from an ONNX AttributeProto.

• onnx_utils.get_op_name: Construct the qualified name of the ONNX operator.

• ops_impl.cast_to_float: Cast values to floating points.

• ops_impl.numpy_abs: Compute abs in numpy according to ONNX spec.

• ops_impl.numpy_acos: Compute acos in numpy according to ONNX spec.

• ops_impl.numpy_acosh: Compute acosh in numpy according to ONNX spec.

• ops_impl.numpy_add: Compute add in numpy according to ONNX spec.

• ops_impl.numpy_asin: Compute asin in numpy according to ONNX spec.

• ops_impl.numpy_asinh: Compute sinh in numpy according to ONNX spec.

• ops_impl.numpy_atan: Compute atan in numpy according to ONNX spec.

• ops_impl.numpy_atanh: Compute atanh in numpy according to ONNX spec.

• ops_impl.numpy_avgpool: Compute Average Pooling using Torch.

• ops_impl.numpy_batchnorm: Compute the batch normalization of the input tensor.

• ops_impl.numpy_cast: Execute ONNX cast in Numpy.

• ops_impl.numpy_celu: Compute celu in numpy according to ONNX spec.

• ops_impl.numpy_constant: Return the constant passed as a kwarg.

• ops_impl.numpy_cos: Compute cos in numpy according to ONNX spec.

• ops_impl.numpy_cosh: Compute cosh in numpy according to ONNX spec.

• ops_impl.numpy_div: Compute div in numpy according to ONNX spec.

• ops_impl.numpy_elu: Compute elu in numpy according to ONNX spec.

• ops_impl.numpy_equal: Compute equal in numpy according to ONNX spec.

• ops_impl.numpy_erf: Compute erf in numpy according to ONNX spec.

• ops_impl.numpy_exp: Compute exponential in numpy according to ONNX spec.

• ops_impl.numpy_flatten: Flatten a tensor into a 2d array.

• ops_impl.numpy_floor: Compute Floor in numpy according to ONNX spec.

• ops_impl.numpy_greater: Compute greater in numpy according to ONNX spec.

• ops_impl.numpy_greater_float: Compute greater in numpy according to ONNX spec and cast outputs to floats.

• ops_impl.numpy_greater_or_equal: Compute greater or equal in numpy according to ONNX spec.

• ops_impl.numpy_greater_or_equal_float: Compute greater or equal in numpy according to ONNX specs and cast outputs to floats.

• ops_impl.numpy_hardsigmoid: Compute hardsigmoid in numpy according to ONNX spec.

• ops_impl.numpy_hardswish: Compute hardswish in numpy according to ONNX spec.

• ops_impl.numpy_identity: Compute identity in numpy according to ONNX spec.

• ops_impl.numpy_leakyrelu: Compute leakyrelu in numpy according to ONNX spec.

• ops_impl.numpy_less: Compute less in numpy according to ONNX spec.

• ops_impl.numpy_less_float: Compute less in numpy according to ONNX spec and cast outputs to floats.

• ops_impl.numpy_less_or_equal: Compute less or equal in numpy according to ONNX spec.

• ops_impl.numpy_less_or_equal_float: Compute less or equal in numpy according to ONNX spec and cast outputs to floats.

• ops_impl.numpy_log: Compute log in numpy according to ONNX spec.

• ops_impl.numpy_matmul: Compute matmul in numpy according to ONNX spec.

• ops_impl.numpy_max: Compute Max in numpy according to ONNX spec.

• ops_impl.numpy_min: Compute Min in numpy according to ONNX spec.

• ops_impl.numpy_mul: Compute mul in numpy according to ONNX spec.

• ops_impl.numpy_neg: Compute Negative in numpy according to ONNX spec.

• ops_impl.numpy_not: Compute not in numpy according to ONNX spec.

• ops_impl.numpy_not_float: Compute not in numpy according to ONNX spec and cast outputs to floats.

• ops_impl.numpy_or: Compute or in numpy according to ONNX spec.

• ops_impl.numpy_or_float: Compute or in numpy according to ONNX spec and cast outputs to floats.

• ops_impl.numpy_pow: Compute pow in numpy according to ONNX spec.

• ops_impl.numpy_relu: Compute relu in numpy according to ONNX spec.

• ops_impl.numpy_round: Compute round in numpy according to ONNX spec.

• ops_impl.numpy_selu: Compute selu in numpy according to ONNX spec.

• ops_impl.numpy_sigmoid: Compute sigmoid in numpy according to ONNX spec.

• ops_impl.numpy_sign: Compute Sign in numpy according to ONNX spec.

• ops_impl.numpy_sin: Compute sin in numpy according to ONNX spec.

• ops_impl.numpy_sinh: Compute sinh in numpy according to ONNX spec.

• ops_impl.numpy_softmax: Compute softmax in numpy according to ONNX spec.

• ops_impl.numpy_softplus: Compute softplus in numpy according to ONNX spec.

• ops_impl.numpy_sub: Compute sub in numpy according to ONNX spec.

• ops_impl.numpy_tan: Compute tan in numpy according to ONNX spec.

• ops_impl.numpy_tanh: Compute tanh in numpy according to ONNX spec.

• ops_impl.numpy_thresholdedrelu: Compute thresholdedrelu in numpy according to ONNX spec.

• ops_impl.numpy_transpose: Transpose in numpy according to ONNX spec.

• ops_impl.numpy_where: Compute the equivalent of numpy.where.

• ops_impl.numpy_where_body: Compute the equivalent of numpy.where.

• ops_impl.onnx_func_raw_args: Decorate a numpy onnx function to flag the raw/non quantized inputs.

• quantizers.fill_from_kwargs: Fill a parameter set structure from kwargs parameters.

• tree_to_numpy.tree_to_numpy: Convert the tree inference to a numpy functions using Hummingbird.

• compile.compile_brevitas_qat_model: Compile a Brevitas Quantization Aware Training model.

• compile.compile_onnx_model: Compile a torch module into an FHE equivalent.

• compile.compile_torch_model: Compile a torch module into an FHE equivalent.

• compile.convert_torch_tensor_or_numpy_array_to_numpy_array: Convert a torch tensor or a numpy array to a numpy array.

module concrete.ml.common.debugging.custom_assert

Provide some variants of assert.

function assert_true

Provide a custom assert to check that the condition is True.

Args:

• condition (bool): the condition. If False, raise AssertionError

• on_error_msg (str): optional message for precising the error, in case of error

• error_type (Type[Exception]): the type of error to raise, if condition is not fulfilled. Default to AssertionError

function assert_false

Provide a custom assert to check that the condition is False.

Args:

• condition (bool): the condition. If True, raise AssertionError

• on_error_msg (str): optional message for precising the error, in case of error

• error_type (Type[Exception]): the type of error to raise, if condition is not fulfilled. Default to AssertionError

function assert_not_reached

Provide a custom assert to check that a piece of code is never reached.

Args:

• on_error_msg (str): message for precising the error

• error_type (Type[Exception]): the type of error to raise, if condition is not fulfilled. Default to AssertionError

module concrete.ml.deployment

Module for deployment of the FHE model.

Global Variables

• fhe_client_server

module concrete.ml.onnx

ONNX module.

Global Variables

• onnx_impl_utils

• ops_impl

• onnx_utils

• convert

• onnx_model_manipulations

module concrete.ml.common.debugging

Module for debugging.

Global Variables

• custom_assert

module concrete.ml.common.utils

Utils that can be re-used by other pieces of code in the module.

Global Variables

• DEFAULT_P_ERROR_PBS

function replace_invalid_arg_name_chars

Sanitize arg_name, replacing invalid chars by _.

This does not check that the starting character of arg_name is valid.

Args:

• arg_name (str): the arg name to sanitize.

Returns:

• str: the sanitized arg name, with only chars in _VALID_ARG_CHARS.

function generate_proxy_function

Generate a proxy function for a function accepting only *args type arguments.

This returns a runtime compiled function with the sanitized argument names passed in desired_functions_arg_names as the arguments to the function.

Args:

• function_to_proxy (Callable): the function defined like def f(*args) for which to return a function like f_proxy(arg_1, arg_2) for any number of arguments.

• desired_functions_arg_names (Iterable[str]): the argument names to use, these names are sanitized and the mapping between the original argument name to the sanitized one is returned in a dictionary. Only the sanitized names will work for a call to the proxy function.

Returns:

• Tuple[Callable, Dict[str, str]]: the proxy function and the mapping of the original arg name to the new and sanitized arg names.

function get_onnx_opset_version

Return the ONNX opset_version.

Args:

• onnx_model (onnx.ModelProto): the model.

Returns:

• int: the version of the model

module concrete.ml.common.check_inputs

Check and conversion tools.

Utils that are used to check (including convert) some data types which are compatible with scikit-learn to numpy types.

function check_array_and_assert

sklearn.utils.check_array with an assert.

Equivalent of sklearn.utils.check_array, with a final assert that the type is one which is supported by Concrete-ML.

Args:

• X (object): Input object to check / convert

Returns: The converted and validated array

function check_X_y_and_assert

sklearn.utils.check_X_y with an assert.

Equivalent of sklearn.utils.check_X_y, with a final assert that the type is one which is supported by Concrete-ML.

Args:

• X (ndarray, list, sparse matrix): Input data

• y (ndarray, list, sparse matrix): Labels

• *args: The arguments to pass to check_X_y

• **kwargs: The keyword arguments to pass to check_X_y

Returns: The converted and validated arrays

module concrete.ml.deployment.fhe_client_server

APIs for FHE deployment.

Global Variables

• CML_VERSION

• AVAILABLE_MODEL

class FHEModelServer

Server API to load and run the FHE circuit.

method __init__

Initialize the FHE API.

Args:

• path_dir (str): the path to the directory where the circuit is saved

method load

Load the circuit.

method run

Run the model on the server over encrypted data.

Args:

• serialized_encrypted_quantized_data (cnp.PublicArguments): the encrypted, quantized and serialized data

• serialized_evaluation_keys (cnp.EvaluationKeys): the serialized evaluation keys

Returns:

• cnp.PublicResult: the result of the model

class FHEModelDev

Dev API to save the model and then load and run the FHE circuit.

method __init__

Initialize the FHE API.

Args:

• path_dir (str): the path to the directory where the circuit is saved

• model (Any): the model to use for the FHE API

method save

Export all needed artifacts for the client and server.

Raises:

• Exception: path_dir is not empty

class FHEModelClient

Client API to encrypt and decrypt FHE data.

method __init__

Initialize the FHE API.

Args:

• path_dir (str): the path to the directory where the circuit is saved

• key_dir (str): the path to the directory where the keys are stored

method deserialize_decrypt

Deserialize and decrypt the values.

Args:

• serialized_encrypted_quantized_result (cnp.PublicArguments): the serialized, encrypted and quantized result

Returns:

• numpy.ndarray: the decrypted and desarialized values

method deserialize_decrypt_dequantize

Deserialize, decrypt and dequantize the values.

Args:

• serialized_encrypted_quantized_result (cnp.PublicArguments): the serialized, encrypted and quantized result

Returns:

• numpy.ndarray: the decrypted (dequantized) values

method generate_private_and_evaluation_keys

Generate the private and evaluation keys.

Args:

• force (bool): if True, regenerate the keys even if they already exist

method get_serialized_evaluation_keys

Get the serialized evaluation keys.

Returns:

• cnp.EvaluationKeys: the evaluation keys

method load

Load the quantizers along with the FHE specs.

method quantize_encrypt_serialize

Quantize, encrypt and serialize the values.

Args:

• x (numpy.ndarray): the values to quantize, encrypt and serialize

Returns:

• cnp.PublicArguments: the quantized, encrypted and serialized values

module concrete.ml.quantization

Modules for quantization.

Global Variables

• quantizers

• base_quantized_op

• quantized_module

• post_training

• quantized_ops

module concrete.ml.onnx.ops_impl

ONNX ops implementation in python + numpy.

function cast_to_float

cast_to_float(inputs)

Cast values to floating points.

Args:

• inputs (Tuple[numpy.ndarray]): The values to consider.

Returns:

• Tuple[numpy.ndarray]: The float values.

function onnx_func_raw_args

onnx_func_raw_args(*args)

Decorate a numpy onnx function to flag the raw/non quantized inputs.

Args:

• *args (tuple[Any]): function argument names

Returns:

• result (ONNXMixedFunction): wrapped numpy function with a list of mixed arguments

function numpy_where_body

numpy_where_body(c: ndarray, t: ndarray, f: Union[ndarray, int]) → ndarray

Compute the equivalent of numpy.where.

This function is not mapped to any ONNX operator (as opposed to numpy_where). It is usable by functions which are mapped to ONNX operators, e.g. numpy_div or numpy_where.

Args:

• c (numpy.ndarray): Condition operand.

• t (numpy.ndarray): True operand.

• f (numpy.ndarray): False operand.

Returns:

• numpy.ndarray: numpy.where(c, t, f)

function numpy_where

numpy_where(c: ndarray, t: ndarray, f: ndarray) → Tuple[ndarray]

Compute the equivalent of numpy.where.

Args:

• c (numpy.ndarray): Condition operand.

• t (numpy.ndarray): True operand.

• f (numpy.ndarray): False operand.

Returns:

• numpy.ndarray: numpy.where(c, t, f)

function numpy_add

numpy_add(a: ndarray, b: ndarray) → Tuple[ndarray]

Compute add in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Add-13

Args:

• a (numpy.ndarray): First operand.

• b (numpy.ndarray): Second operand.

Returns:

• Tuple[numpy.ndarray]: Result, has same element type as two inputs

function numpy_constant

numpy_constant(**kwargs)

Return the constant passed as a kwarg.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Constant-13

Args:

• **kwargs: keyword arguments

Returns:

• Any: The stored constant.

function numpy_matmul

numpy_matmul(a: ndarray, b: ndarray) → Tuple[ndarray]

Compute matmul in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#MatMul-13

Args:

• a (numpy.ndarray): N-dimensional matrix A

• b (numpy.ndarray): N-dimensional matrix B

Returns:

• Tuple[numpy.ndarray]: Matrix multiply results from A * B

function numpy_relu

numpy_relu(x: ndarray) → Tuple[ndarray]

Compute relu in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Relu-14

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_sigmoid

numpy_sigmoid(x: ndarray) → Tuple[ndarray]

Compute sigmoid in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Sigmoid-13

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_softmax

numpy_softmax(x, axis=1, keepdims=True)

Compute softmax in numpy according to ONNX spec.

Softmax is currently not supported in FHE.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#softmax-13

Args:

• x (numpy.ndarray): Input tensor

• axis (None, int, tuple of ints): Axis or axes along which a softmax's sum is performed. If None, it will sum all of the elements of the input array. If axis is negative it counts from the last to the first axis. Default to 1.

• keepdims (bool): If True, the axes which are reduced along the sum are left in the result as dimensions with size one. Default to True.

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_cos

numpy_cos(x: ndarray) → Tuple[ndarray]

Compute cos in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Cos-7

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_cosh

numpy_cosh(x: ndarray) → Tuple[ndarray]

Compute cosh in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Cosh-9

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_sin

numpy_sin(x: ndarray) → Tuple[ndarray]

Compute sin in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Sin-7

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_sinh

numpy_sinh(x: ndarray) → Tuple[ndarray]

Compute sinh in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Sinh-9

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_tan

numpy_tan(x: ndarray) → Tuple[ndarray]

Compute tan in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Tan-7

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_tanh

numpy_tanh(x: ndarray) → Tuple[ndarray]

Compute tanh in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Tanh-13

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_acos

numpy_acos(x: ndarray) → Tuple[ndarray]

Compute acos in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Acos-7

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_acosh

numpy_acosh(x: ndarray) → Tuple[ndarray]

Compute acosh in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Acosh-9

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_asin

numpy_asin(x: ndarray) → Tuple[ndarray]

Compute asin in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Asin-7

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_asinh

numpy_asinh(x: ndarray) → Tuple[ndarray]

Compute sinh in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Asinh-9

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_atan

numpy_atan(x: ndarray) → Tuple[ndarray]

Compute atan in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Atan-7

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_atanh

numpy_atanh(x: ndarray) → Tuple[ndarray]

Compute atanh in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Atanh-9

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_elu

numpy_elu(x: ndarray, alpha: float = 1) → Tuple[ndarray]

Compute elu in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Elu-6

Args:

• x (numpy.ndarray): Input tensor

• alpha (float): Coefficient

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_selu

numpy_selu(
    x: ndarray,
    alpha: float = 1.6732632423543772,
    gamma: float = 1.0507009873554805
) → Tuple[ndarray]

Compute selu in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Selu-6

Args:

• x (numpy.ndarray): Input tensor

• alpha (float): Coefficient

• gamma (float): Coefficient

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_celu

numpy_celu(x: ndarray, alpha: float = 1) → Tuple[ndarray]

Compute celu in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Celu-12

Args:

• x (numpy.ndarray): Input tensor

• alpha (float): Coefficient

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_leakyrelu

numpy_leakyrelu(x: ndarray, alpha: float = 0.01) → Tuple[ndarray]

Compute leakyrelu in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#LeakyRelu-6

Args:

• x (numpy.ndarray): Input tensor

• alpha (float): Coefficient

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_thresholdedrelu

numpy_thresholdedrelu(x: ndarray, alpha: float = 1) → Tuple[ndarray]

Compute thresholdedrelu in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#ThresholdedRelu-10

Args:

• x (numpy.ndarray): Input tensor

• alpha (float): Coefficient

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_hardsigmoid

numpy_hardsigmoid(
    x: ndarray,
    alpha: float = 0.2,
    beta: float = 0.5
) → Tuple[ndarray]

Compute hardsigmoid in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#HardSigmoid-6

Args:

• x (numpy.ndarray): Input tensor

• alpha (float): Coefficient

• beta (float): Coefficient

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_softplus

numpy_softplus(x: ndarray) → Tuple[ndarray]

Compute softplus in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Softplus-1

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_abs

numpy_abs(x: ndarray) → Tuple[ndarray]

Compute abs in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Abs-13

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_div

numpy_div(a: ndarray, b: ndarray) → Tuple[ndarray]

Compute div in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Div-14

Args:

• a (numpy.ndarray): Input tensor

• b (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_mul

numpy_mul(a: ndarray, b: ndarray) → Tuple[ndarray]

Compute mul in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Mul-14

Args:

• a (numpy.ndarray): Input tensor

• b (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_sub

numpy_sub(a: ndarray, b: ndarray) → Tuple[ndarray]

Compute sub in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Sub-14

Args:

• a (numpy.ndarray): Input tensor

• b (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_log

numpy_log(x: ndarray) → Tuple[ndarray]

Compute log in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Log-13

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_erf

numpy_erf(x: ndarray) → Tuple[ndarray]

Compute erf in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Erf-13

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_hardswish

numpy_hardswish(x: ndarray) → Tuple[ndarray]

Compute hardswish in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#hardswish-14

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_exp

numpy_exp(x: ndarray) → Tuple[ndarray]

Compute exponential in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Exp-13

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: The exponential of the input tensor computed element-wise

function numpy_equal

numpy_equal(x: ndarray, y: ndarray) → Tuple[ndarray]

Compute equal in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Equal-11

Args:

• x (numpy.ndarray): Input tensor

• y (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_not

numpy_not(x: ndarray) → Tuple[ndarray]

Compute not in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Not-1

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_not_float

numpy_not_float(x: ndarray) → Tuple[ndarray]

Compute not in numpy according to ONNX spec and cast outputs to floats.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Not-1

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_greater

numpy_greater(x: ndarray, y: ndarray) → Tuple[ndarray]

Compute greater in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Greater-13

Args:

• x (numpy.ndarray): Input tensor

• y (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_greater_float

numpy_greater_float(x: ndarray, y: ndarray) → Tuple[ndarray]

Compute greater in numpy according to ONNX spec and cast outputs to floats.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Greater-13

Args:

• x (numpy.ndarray): Input tensor

• y (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_greater_or_equal

numpy_greater_or_equal(x: ndarray, y: ndarray) → Tuple[ndarray]

Compute greater or equal in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#GreaterOrEqual-12

Args:

• x (numpy.ndarray): Input tensor

• y (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_greater_or_equal_float

numpy_greater_or_equal_float(x: ndarray, y: ndarray) → Tuple[ndarray]

Compute greater or equal in numpy according to ONNX specs and cast outputs to floats.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#GreaterOrEqual-12

Args:

• x (numpy.ndarray): Input tensor

• y (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_less

numpy_less(x: ndarray, y: ndarray) → Tuple[ndarray]

Compute less in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Less-13

Args:

• x (numpy.ndarray): Input tensor

• y (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_less_float

numpy_less_float(x: ndarray, y: ndarray) → Tuple[ndarray]

Compute less in numpy according to ONNX spec and cast outputs to floats.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Less-13

Args:

• x (numpy.ndarray): Input tensor

• y (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_less_or_equal

numpy_less_or_equal(x: ndarray, y: ndarray) → Tuple[ndarray]

Compute less or equal in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#LessOrEqual-12

Args:

• x (numpy.ndarray): Input tensor

• y (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_less_or_equal_float

numpy_less_or_equal_float(x: ndarray, y: ndarray) → Tuple[ndarray]

Compute less or equal in numpy according to ONNX spec and cast outputs to floats.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#LessOrEqual-12

Args:

• x (numpy.ndarray): Input tensor

• y (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_identity

numpy_identity(x: ndarray) → Tuple[ndarray]

Compute identity in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Identity-14

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_transpose

numpy_transpose(x: ndarray, perm=None) → Tuple[ndarray]

Transpose in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Transpose-13

Args:

• x (numpy.ndarray): Input tensor

• perm (numpy.ndarray): Permutation of the axes

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_avgpool

numpy_avgpool(
    x: ndarray,
    ceil_mode: int,
    kernel_shape: Tuple[int, ],
    pads: Tuple[int, ] = None,
    strides: Tuple[int, ] = None
) → Tuple[ndarray]

Compute Average Pooling using Torch.

Currently supports 2d average pooling with torch semantics. This function is ONNX compatible.

See: https://github.com/onnx/onnx/blob/main/docs/Operators.md#AveragePool

Args:

• x (numpy.ndarray): input data (many dtypes are supported). Shape is N x C x H x W for 2d

• ceil_mode (int): ONNX rounding parameter, expected 0 (torch style dimension computation)

• kernel_shape (Tuple[int, ...]): shape of the kernel. Should have 2 elements for 2d conv

• pads (Tuple[int, ...]): padding in ONNX format (begin, end) on each axis

• strides (Tuple[int, ...]): stride of the convolution on each axis

Returns:

• res (numpy.ndarray): a tensor of size (N x InChannels x OutHeight x OutWidth).

• See https: //pytorch.org/docs/stable/generated/torch.nn.AvgPool2d.html

Raises:

• AssertionError: if the pooling arguments are wrong

function numpy_cast

numpy_cast(data: ndarray, to: int) → Tuple[ndarray]

Execute ONNX cast in Numpy.

Supports only booleans for now, which are converted to integers.

See: https://github.com/onnx/onnx/blob/main/docs/Operators.md#Cast

Args:

• data (numpy.ndarray): Input encrypted tensor

• to (int): integer value of the onnx.TensorProto DataType enum

Returns:

• result (numpy.ndarray): a tensor with the required data type

function numpy_batchnorm

numpy_batchnorm(
    x: ndarray,
    scale: ndarray,
    bias: ndarray,
    input_mean: ndarray,
    input_var: ndarray,
    epsilon=1e-05,
    momentum=0.9,
    training_mode=0
) → Tuple[ndarray]

Compute the batch normalization of the input tensor.

This can be expressed as:

Y = (X - input_mean) / sqrt(input_var + epsilon) * scale + B

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#BatchNormalization-14

Args:

• x (numpy.ndarray): tensor to normalize, dimensions are in the form of (N,C,D1,D2,...,Dn), where N is the batch size, C is the number of channels.

• scale (numpy.ndarray): scale tensor of shape (C,)

• bias (numpy.ndarray): bias tensor of shape (C,)

• input_mean (numpy.ndarray): mean values to use for each input channel, shape (C,)

• input_var (numpy.ndarray): variance values to use for each input channel, shape (C,)

• epsilon (float): avoids division by zero

• momentum (float): momentum used during training of the mean/variance, not used in inference

• training_mode (int): if the model was exported in training mode this is set to 1, else 0

Returns:

• numpy.ndarray: Normalized tensor

function numpy_flatten

numpy_flatten(x: ndarray, axis: int = 1) → Tuple[ndarray]

Flatten a tensor into a 2d array.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Flatten-13.

Args:

• x (numpy.ndarray): tensor to flatten

• axis (int): axis after which all dimensions will be flattened (axis=0 gives a 1D output)

Returns:

• result: flattened tensor

function numpy_or

numpy_or(a: ndarray, b: ndarray) → Tuple[ndarray]

Compute or in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Or-7

Args:

• a (numpy.ndarray): Input tensor

• b (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_or_float

numpy_or_float(a: ndarray, b: ndarray) → Tuple[ndarray]

Compute or in numpy according to ONNX spec and cast outputs to floats.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Or-7

Args:

• a (numpy.ndarray): Input tensor

• b (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_round

numpy_round(a: ndarray) → Tuple[ndarray]

Compute round in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Round-11 Remark that ONNX Round operator is actually a rint, since the number of decimals is forced to be 0

Args:

• a (numpy.ndarray): Input tensor whose elements to be rounded.

Returns:

• Tuple[numpy.ndarray]: Output tensor with rounded input elements.

function numpy_pow

numpy_pow(a: ndarray, b: ndarray) → Tuple[ndarray]

Compute pow in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Pow-13

Args:

• a (numpy.ndarray): Input tensor whose elements to be raised.

• b (numpy.ndarray): The power to which we want to raise.

Returns:

• Tuple[numpy.ndarray]: Output tensor.

function numpy_floor

numpy_floor(x: ndarray) → Tuple[ndarray]

Compute Floor in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Floor-1

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_max

numpy_max(a: ndarray, b: ndarray) → Tuple[ndarray]

Compute Max in numpy according to ONNX spec.

Computes the max between the first input and a float constant.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Max-1

Args:

• a (numpy.ndarray): Input tensor

• b (numpy.ndarray): Constant tensor to compare to the first input

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_min

numpy_min(a: ndarray, b: ndarray) → Tuple[ndarray]

Compute Min in numpy according to ONNX spec.

Computes the minimum between the first input and a float constant.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Max-1

Args:

• a (numpy.ndarray): Input tensor

• b (numpy.ndarray): Constant tensor to compare to the first input

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_sign

numpy_sign(x: ndarray) → Tuple[ndarray]

Compute Sign in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Sign-9

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

function numpy_neg

numpy_neg(x: ndarray) → Tuple[ndarray]

Compute Negative in numpy according to ONNX spec.

See https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Sign-9

Args:

• x (numpy.ndarray): Input tensor

Returns:

• Tuple[numpy.ndarray]: Output tensor

class ONNXMixedFunction

A mixed quantized-raw valued onnx function.

ONNX functions will take inputs which can be either quantized or float. Some functions only take quantized inputs, but some functions take both types. For mixed functions we need to tag the parameters that do not need quantization. Thus quantized ops can know which inputs are not QuantizedArray and we avoid unnecessary wrapping of float values as QuantizedArrays.

method __init__

__init__(function, non_quant_params: Set[str])

Create the mixed function and raw parameter list.

Args:

• function (Any): function to be decorated

• non_quant_params: Set[str]: set of parameters that will not be quantized (stored as numpy.ndarray)

module concrete.ml.onnx.convert

ONNX conversion related code.

Global Variables

• IMPLEMENTED_ONNX_OPS

• OPSET_VERSION_FOR_ONNX_EXPORT

function get_equivalent_numpy_forward_and_onnx_model

get_equivalent_numpy_forward_and_onnx_model(
    torch_module: Module,
    dummy_input: Union[Tensor, Tuple[Tensor, ]],
    output_onnx_file: Optional[Path, str] = None
) → Tuple[Callable[, Tuple[ndarray, ]], GraphProto]

Get the numpy equivalent forward of the provided torch Module.

Args:

• torch_module (torch.nn.Module): the torch Module for which to get the equivalent numpy forward.

• dummy_input (Union[torch.Tensor, Tuple[torch.Tensor, ...]]): dummy inputs for ONNX export.

• output_onnx_file (Optional[Union[Path, str]]): Path to save the ONNX file to. Will use a temp file if not provided. Defaults to None.

Returns:

• Tuple[Callable[..., Tuple[numpy.ndarray, ...]], onnx.GraphProto]: The function that will execute the equivalent numpy code to the passed torch_module and the generated ONNX model.

function get_equivalent_numpy_forward

get_equivalent_numpy_forward(
    onnx_model: ModelProto,
    check_model: bool = True
) → Callable[, Tuple[ndarray, ]]

Get the numpy equivalent forward of the provided ONNX model.

Args:

• onnx_model (onnx.ModelProto): the ONNX model for which to get the equivalent numpy forward.

• check_model (bool): set to True to run the onnx checker on the model. Defaults to True.

Raises:

• ValueError: Raised if there is an unsupported ONNX operator required to convert the torch model to numpy.

Returns:

• Callable[..., Tuple[numpy.ndarray, ...]]: The function that will execute the equivalent numpy function.

module concrete.ml.onnx.onnx_model_manipulations

Some code to manipulate models.

function simplify_onnx_model

simplify_onnx_model(onnx_model: ModelProto)

Simplify an ONNX model, removes unused Constant nodes and Identity nodes.

Args:

• onnx_model (onnx.ModelProto): the model to simplify.

function remove_unused_constant_nodes

remove_unused_constant_nodes(onnx_model: ModelProto)

Remove unused Constant nodes in the provided onnx model.

Args:

• onnx_model (onnx.ModelProto): the model for which we want to remove unused Constant nodes.

function remove_identity_nodes

remove_identity_nodes(onnx_model: ModelProto)

Remove identity nodes from a model.

Args:

• onnx_model (onnx.ModelProto): the model for which we want to remove Identity nodes.

function keep_following_outputs_discard_others

keep_following_outputs_discard_others(
    onnx_model: ModelProto,
    outputs_to_keep: Iterable[str]
)

Keep the outputs given in outputs_to_keep and remove the others from the model.

Args:

• onnx_model (onnx.ModelProto): the ONNX model to modify.

• outputs_to_keep (Iterable[str]): the outputs to keep by name.

function remove_node_types

remove_node_types(onnx_model: ModelProto, op_types_to_remove: List[str])

Remove unnecessary nodes from the ONNX graph.

Args:

• onnx_model (onnx.ModelProto): The ONNX model to modify.

• op_types_to_remove (List[str]): The node types to remove from the graph.

Raises:

• ValueError: Wrong replacement by an Identity node.

function clean_graph_after_node_name

clean_graph_after_node_name(
    onnx_model: ModelProto,
    node_name: str,
    fail_if_not_found: bool = True
)

Clean the graph of the onnx model by removing nodes after the given node name.

Args:

• onnx_model (onnx.ModelProto): The onnx model.

• node_name (str): The node's name whose following nodes will be removed.

• fail_if_not_found (bool): If true, abort if the node name is not found

Raises:

• ValueError: if the node name is not found and if fail_if_not_found is set

function clean_graph_after_node_op_type

clean_graph_after_node_op_type(
    onnx_model: ModelProto,
    node_op_type: str,
    fail_if_not_found: bool = True
)

Clean the graph of the onnx model by removing nodes after the given node type.

Args:

• onnx_model (onnx.ModelProto): The onnx model.

• node_op_type (str): The node's op_type whose following nodes will be removed.

• fail_if_not_found (bool): If true, abort if the node op_type is not found

Raises:

• ValueError: if the node op_type is not found and if fail_if_not_found is set

module concrete.ml.quantization.post_training

Post Training Quantization methods.

Global Variables

• ONNX_OPS_TO_NUMPY_IMPL

• DEFAULT_MODEL_BITS

• ONNX_OPS_TO_QUANTIZED_IMPL

class ONNXConverter

Base ONNX to Concrete ML computation graph conversion class.

This class provides a method to parse an ONNX graph and apply several transformations. First, it creates QuantizedOps for each ONNX graph op. These quantized ops have calibrated quantizers that are useful when the operators work on integer data or when the output of the ops is the output of the encrypted program. For operators that compute in float and will be merged to TLUs, these quantizers are not used. Second, this converter creates quantized tensors for initializer and weights stored in the graph.

This class should be sub-classed to provide specific calibration and quantization options depending on the usage (Post-training quantization vs Quantization Aware training).

Arguments:

• n_bits (int, Dict[str, int]): number of bits for quantization, can be a single value or a dictionary with the following keys : - "op_inputs" and "op_weights" (mandatory) - "model_inputs" and "model_outputs" (optional, default to 5 bits). When using a single integer for n_bits, its value is assigned to "op_inputs" and "op_weights" bits. The maximum between this value and a default value (5) is then assigned to the number of "model_inputs" "model_outputs". This default value is a compromise between model accuracy and runtime performance in FHE. "model_outputs" gives the precision of the final network's outputs, while "model_inputs" gives the precision of the network's inputs. "op_inputs" and "op_weights" both control the quantization for inputs and weights of all layers.

• y_model (NumpyModule): Model in numpy.

• is_signed (bool): Whether the weights of the layers can be signed. Currently, only the weights can be signed.

method __init__

__init__(
    n_bits: Union[int, Dict],
    numpy_model: NumpyModule,
    is_signed: bool = False
)

property n_bits_model_inputs

Get the number of bits to use for the quantization of the first layer's output.

Returns:

• n_bits (int): number of bits for input quantization

property n_bits_model_outputs

Get the number of bits to use for the quantization of the last layer's output.

Returns:

• n_bits (int): number of bits for output quantization

property n_bits_op_inputs

Get the number of bits to use for the quantization of any operators' inputs.

Returns:

• n_bits (int): number of bits for the quantization of the operators' inputs

property n_bits_op_weights

Get the number of bits to use for the quantization of any constants (usually weights).

Returns:

• n_bits (int): number of bits for quantizing constants used by operators

method quantize_module

quantize_module(*calibration_data: ndarray) → QuantizedModule

Quantize numpy module.

Following https://arxiv.org/abs/1712.05877 guidelines.

Args:

• *calibration_data (numpy.ndarray): Data that will be used to compute the bounds, scales and zero point values for every quantized object.

Returns:

• QuantizedModule: Quantized numpy module

class PostTrainingAffineQuantization

Post-training Affine Quantization.

Create the quantized version of the passed numpy module.

Args:

• n_bits (int, Dict): Number of bits to quantize the model. If an int is passed for n_bits, the value will be used for activation, inputs and weights. If a dict is passed, then it should contain "model_inputs", "op_inputs", "op_weights" and "model_outputs" keys with corresponding number of quantization bits for: - model_inputs : number of bits for model input - op_inputs : number of bits to quantize layer input values - op_weights: learned parameters or constants in the network - model_outputs: final model output quantization bits

• numpy_model (NumpyModule): Model in numpy.

• is_signed: Whether the weights of the layers can be signed. Currently, only the weights can be signed.

Returns:

• QuantizedModule: A quantized version of the numpy model.

method __init__

__init__(
    n_bits: Union[int, Dict],
    numpy_model: NumpyModule,
    is_signed: bool = False
)

property n_bits_model_inputs

Get the number of bits to use for the quantization of the first layer's output.

Returns:

• n_bits (int): number of bits for input quantization

property n_bits_model_outputs

Get the number of bits to use for the quantization of the last layer's output.

Returns:

• n_bits (int): number of bits for output quantization

property n_bits_op_inputs

Get the number of bits to use for the quantization of any operators' inputs.

Returns:

• n_bits (int): number of bits for the quantization of the operators' inputs

property n_bits_op_weights

Get the number of bits to use for the quantization of any constants (usually weights).

Returns:

• n_bits (int): number of bits for quantizing constants used by operators

method quantize_module

quantize_module(*calibration_data: ndarray) → QuantizedModule

Quantize numpy module.

Following https://arxiv.org/abs/1712.05877 guidelines.

Args:

• *calibration_data (numpy.ndarray): Data that will be used to compute the bounds, scales and zero point values for every quantized object.

Returns:

• QuantizedModule: Quantized numpy module

class PostTrainingQATImporter

Converter of Quantization Aware Training networks.

This class provides specific configuration for QAT networks during ONNX network conversion to Concrete ML computation graphs.

method __init__

__init__(
    n_bits: Union[int, Dict],
    numpy_model: NumpyModule,
    is_signed: bool = False
)

property n_bits_model_inputs

Get the number of bits to use for the quantization of the first layer's output.

Returns:

• n_bits (int): number of bits for input quantization

property n_bits_model_outputs

Get the number of bits to use for the quantization of the last layer's output.

Returns:

• n_bits (int): number of bits for output quantization

property n_bits_op_inputs

Get the number of bits to use for the quantization of any operators' inputs.

Returns:

• n_bits (int): number of bits for the quantization of the operators' inputs

property n_bits_op_weights

Get the number of bits to use for the quantization of any constants (usually weights).

Returns:

• n_bits (int): number of bits for quantizing constants used by operators

method quantize_module

quantize_module(*calibration_data: ndarray) → QuantizedModule

Quantize numpy module.

Following https://arxiv.org/abs/1712.05877 guidelines.

Args:

• *calibration_data (numpy.ndarray): Data that will be used to compute the bounds, scales and zero point values for every quantized object.

Returns:

• QuantizedModule: Quantized numpy module

module concrete.ml.quantization.base_quantized_op

Base Quantized Op class that implements quantization for a float numpy op.

Global Variables

• ONNX_OPS_TO_NUMPY_IMPL

• ALL_QUANTIZED_OPS

• ONNX_OPS_TO_QUANTIZED_IMPL

• DEFAULT_MODEL_BITS

class QuantizedOp

Base class for quantized ONNX ops implemented in numpy.

Args:

• n_bits_output (int): The number of bits to use for the quantization of the output

• int_input_names (Set[str]): The set of names of integer tensors that are inputs to this op

• constant_inputs (Optional[Union[Dict[str, Any], Dict[int, Any]]]): The constant tensors that are inputs to this op

• input_quant_opts (QuantizationOptions): Input quantizer options, determine the quantization that is applied to input tensors (that are not constants)

method __init__

__init__(
    n_bits_output: int,
    int_input_names: Optional[Set[str]] = None,
    constant_inputs: Optional[Dict[str, Any], Dict[int, Any]] = None,
    input_quant_opts: Optional[QuantizationOptions] = None,
    **attrs
) → None

property op_type

Get the type of this operation.

Returns:

• op_type (str): The type of this operation, in the ONNX referential

method calibrate

calibrate(*inputs: ndarray) → ndarray

Create corresponding QuantizedArray for the output of the activation function.

Args:

• *inputs (numpy.ndarray): Calibration sample inputs.

Returns:

• numpy.ndarray: the output values for the provided calibration samples.

method call_impl

call_impl(*inputs: Optional[ndarray, QuantizedArray], **attrs) → ndarray

Call self.impl to centralize mypy bug workaround.

Args:

• *inputs (numpy.ndarray): real valued inputs.

• **attrs: the QuantizedOp attributes.

Returns:

• numpy.ndarray: return value of self.impl

method can_fuse

can_fuse() → bool

Determine if the operator impedes graph fusion.

This function shall be overloaded by inheriting classes to test self._int_input_names, to determine whether the operation can be fused to a TLU or not. For example an operation that takes inputs produced by a unique integer tensor can be fused to a TLU. Example: f(x) = x * (x + 1) can be fused. A function that does f(x) = x * (x @ w + 1) can't be fused.

Returns:

• bool: whether this instance of the QuantizedOp produces Concrete Numpy code that can be fused to TLUs

classmethod must_quantize_input

must_quantize_input(input_name_or_idx: int) → bool

Determine if an input must be quantized.

Quantized ops and numpy onnx ops take inputs and attributes. Inputs can be either constant or variable (encrypted). Note that this does not handle attributes, which are handled by QuantizedOp classes separately in their constructor.

Args:

• input_name_or_idx (int): Index of the input to check.

Returns:

• result (bool): Whether the input must be quantized (must be a QuantizedArray) or if it stays as a raw numpy.array read from ONNX.

method prepare_output

prepare_output(qoutput_activation: ndarray) → QuantizedArray

Quantize the output of the activation function.

The calibrate method needs to be called with sample data before using this function.

Args:

• qoutput_activation (numpy.ndarray): Output of the activation function.

Returns:

• QuantizedArray: Quantized output.

method q_impl

q_impl(*q_inputs: QuantizedArray, **attrs) → QuantizedArray

Execute the quantized forward.

Args:

• *q_inputs (QuantizedArray): Quantized inputs.

• **attrs: the QuantizedOp attributes.

Returns:

• QuantizedArray: The returned quantized value.

class QuantizedOpUnivariateOfEncrypted

An univariate operator of an encrypted value.

This operation is not really operating as a quantized operation. It is useful when the computations get fused into a TLU, as in e.g. Act(x) = x || (x + 42)).

method __init__

__init__(
    n_bits_output: int,
    int_input_names: Optional[Set[str]] = None,
    constant_inputs: Optional[Dict[str, Any], Dict[int, Any]] = None,
    input_quant_opts: Optional[QuantizationOptions] = None,
    **attrs
) → None

property op_type

Get the type of this operation.

Returns:

• op_type (str): The type of this operation, in the ONNX referential

method calibrate

calibrate(*inputs: ndarray) → ndarray