1 of 70

0.5 What is Concrete ML?

⭐️ Star the repo on Github | 🗣 Community support forum | 📁 Contribute to the project

Concrete-ML is an open-source privacy-preserving machine learning inference framework based on fully homomorphic encryption (FHE). It enables data scientists without any prior knowledge of cryptography to automatically turn machine learning models into their FHE equivalent, using familiar APIs from Scikit-learn and PyTorch (see how it looks for linear models, tree-based models and neural networks).

Fully Homomorphic Encryption (FHE) is an encryption technique that allows computing directly on encrypted data, without needing to decrypt it. With FHE, you can build private-by-design applications without compromising on features. You can learn more about FHE in this introduction, or by joining the FHE.org community.

Example usage

Here is a simple example of classification on encrypted data using logistic regression. More examples can be found .

This example shows the typical flow of a Concrete-ML model:

The model is trained on unencrypted (plaintext) data using scikit-learn. As FHE operates over integers, Concrete-ML quantizes the model to use only integers during inference.
The quantized model is compiled to a FHE equivalent. Under the hood, the model is first converted to a Concrete-Numpy program, then compiled.
Inference can then be done on encrypted data. The above example shows encrypted inference in the model development phase. Alternatively, in in a client/server setting, the data is encrypted by the client, processed securely by the server and then decrypted by the client.

Current limitations

To make a model work with FHE, the only constraint is to make it run within the supported precision limitations of Concrete-ML (currently 8-bit integers). Thus, machine learning models are required to be quantized, which sometimes leads to a loss of accuracy versus the original model operating on plaintext.

Additionally, Concrete-ML currently only supports FHE inference. On the other hand, training has to be done on unencrypted data, producing a model which is then converted to a FHE equivalent that can perform encrypted inference, i.e. prediction over encrypted data.

Finally, in Concrete-ML there is currently no support for pre-processing model inputs and for post-processing model outputs. These processing stages may involve text to numerical feature transformation, dimensionality reduction, KNN or clustering, featurization, normalization, and the mixing of results of ensemble models.

All of these issues are currently being addressed and significant improvements are expected to be released in the coming months.

Concrete Stack

Concrete-ML is built on top of Zama's Concrete framework. It uses , which itself uses the and the . To use these libraries directly, refer to the and documentations.

Online demos and tutorials.

Various tutorials are proposed for the and for . In addition, we also list standalone use-cases:

: a Python and notebook showing a Quantization Aware Training (done with and following constraints of the package) and its corresponding use in Concrete-ML.
: a notebook, which gives a solution to the . Done with XGBoost from Concrete-ML. It comes as a companion of , and was the subject of a blogpost in .

More generally, if you have built awesome projects using Concrete-ML, feel free to let us know and we'll link to it!

Additional resources

Looking for support? Ask our team!

Support forum: (we answer in less than 24 hours).
Live discussion on the FHE.org discord server: (inside the #concrete channel).
Do you have a question about Zama? You can write us on or send us an email at: [email protected]

Getting Started

Installation

Please note that not all hardware/OS combinations are supported. Determine your platform, OS version and Python version before referencing the table below.

Depending on your OS, Concrete-ML may be installed with Docker or with pip:

OS / HW

Available on Docker

Available on pip

Also, only some versions of python are supported: in the current release, these are 3.7 (linux only), 3.8 and 3.9.

Most of these limits are shared with the rest of the Concrete stack (namely Concrete-Numpy and Concrete-Compiler). Support for more platforms will be added in the future.

Using PyPi

Requirements

Installing Concrete-ML using PyPi requires a Linux-based OS or macOS running on an x86 CPU. For Apple Silicon, Docker is the only currently supported option (see ).

Installing on Windows can be done using Docker or WSL. On WSL, Concrete-ML will work as long as the package is not installed in the /mnt/c/ directory, which corresponds to the host OS filesystem.

Installation

To install Concrete-ML from PyPi, run the following:

This will automatically install all dependencies, notably Concrete-Numpy.

Using Docker

Concrete-ML can be installed using Docker by either pulling the latest image or a specific version:

The image can be used with Docker volumes, .

The image can then be used via the following command:

This will launch a Concrete-ML enabled Jupyter server in Docker that can be accessed directly from a browser.

Alternatively, a shell can be lauched in Docker, with or without volumes:

Key Concepts

Concrete-ML is built on top of Concrete-Numpy, which enables Numpy programs to be converted into FHE circuits.

Lifecycle of a Concrete-ML model

Inference in the Cloud

Concrete-ML models can be easily deployed in a client/server setting, enabling the creation of privacy-preserving services in the cloud.

As seen in the , a Concrete-ML model, once compiled to FHE, generates machine code that performs the inference on private data. Furthermore, secret encryption keys are needed so that the user can securely encrypt their data and decrypt the inference result. An evaluation key is also needed for the server to securely process the user's encrypted data.

Keys are generated by the user once for each service they use, based on the model the service provides and its cryptographic parameters.

The overall communications protocol to enable cloud deployment of machine learning services can be summarized in the following diagram:

Built-in Models

Pandas

Concrete-ML provides partial support for Pandas, with most available models (linear and tree-based models) usable on Pandas dataframes the same way they would be used with NumPy arrays.

The table below summarizes the current compatibility:

Methods

Support Pandas dataframe

fit

✓

compile

✗

Example

The following example considers a LogisticRegression model on a simple classification problem. A more advanced example can be found in the , which considers a XGBClassifier.

Built-in Model Examples

The following table summarizes the various examples in this section, along with their accuracies.

Model

Data-set

Metric

Floating Point

Simulation

FHE

Deep Learning

Deep Learning Examples

Summary

The following table summarizes the examples in this section:

Model

Data-set

Metric

Floating Point

Simulation

FHE

Examples

Advanced topics

Pruning

Pruning is a method to reduce neural network complexity, usually applied in order to reduce the computation cost or memory size. Pruning is used in Concrete-ML to control the size of accumulators in neural networks, thus making them FHE-compatible. See for an explanation of accumulator bit-width constraints.

Overview of pruning in Concrete-ML

Pruning is used in Concrete-ML for two types of neural networks:

Compilation

Compilation of a model produces machine code that executes the model on encrypted data. In some cases, notably in the client/server setting, the compilation can be done by the server when loading the model for serving.

As FHE execution is much slower than execution on non-encrypted data, Concrete-ML has a simulation mode, using an execution mode named the Virtual Library. Since, by default, the cryptographic parameters are chosen such that the results obtained in FHE are the same as those on clear data, the Virtual Library allows you to benchmark models quickly during development.

Compilation

Advanced Features

Concrete-ML offers some features for advanced users that wish to adjust the cryptographic parameters that are generated by the Concrete stack for a certain machine learning model.

Approximate computations using the `p_error` parameter

Concrete-ML makes use of table lookup (TLU) to represent any non-linear operation (e.g. sigmoid). This TLU is implemented through the Programmable Bootstrapping (PBS) operation which will apply a non-linear operation in the cryptographic realm.

Developer Guide

Workflow

Set Up Docker

Before you start this section, you must install Docker by following official guide.

Building the image

Once you have access to this repository and the dev environment is installed on your host OS (via make setup_env once ), you should be able to launch the commands to build the dev Docker image with make docker_build.

Documentation

Using GitBook

Documentation with GitBook is done mainly by pushing content on GitHub. GitBook then pulls the docs from the repository and publishes. In most cases, GitBook is just a mirror of what is available in GitHub.

There are, however, some use-cases where documentation can be modified directly in GitBook (and then, push the modifications to GitHub), for example when the documentation is modified by a person outside of Zama. In this case, a GitHub branch is created, and a GitHub space is associated to it: modifications are done in this space and automatically pushed to the branch. Once the modifications are done, one can simply create a pull-request, to finally merge modifications on the main branch.

Support and Issues

Concrete-ML is a constant work-in-progress, and thus may contain bugs or suboptimal APIs.

Before opening an issue or asking for support, please read this documentation to understand common issues and limitations of Concrete-ML. You can also check the outstanding issues on github.

Furthermore, undefined behavior may occur if the input-set, which is internally used by the compilation core to set bit-widths of some intermediate data, is not sufficiently representative of the future user inputs. With all the inputs in the input-set, it appears that intermediate data can be represented as an n-bit integer. But, for a particular computation, this same intermediate data needs additional bits to be represented. The FHE execution for this computation will result in an incorrect output, as typically occurs in integer overflows in classical programs.

If you didn't find an answer, you can ask a question on the Zama forum, or in the FHE.org discord.

Submitting an issue

When submitting an issue (), ideally include as much information as possible. In addition to the Python script, the following information is useful:

the reproducibility rate you see on your side
any insight you might have on the bug
any workaround you have been able to find

If you would like to contribute to project and send pull requests, take a look at the guide.

Inner workings

Importing ONNX

Internally, Concrete-ML uses operators as intermediate representation (or IR) for manipulating machine learning models produced through export for , and .

As ONNX is becoming the standard exchange format for neural networks, this allows Concrete-ML to be flexible while also making model representation manipulation quite easy. In addition, it allows for straight-forward mapping to NumPy operators, supported by Concrete-Numpy to use Concrete stack's FHE conversion capabilities.

Torch to NumPy conversion using ONNX

concrete.ml.common.debugging

module `concrete.ml.common.debugging`

Module for debugging.

Global Variables

custom_assert

concrete.ml.common.debugging.custom_assert

module `concrete.ml.common.debugging.custom_assert`

Provide some variants of assert.

concrete.ml.common.utils

module `concrete.ml.common.utils`

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

concrete.ml.deployment

module `concrete.ml.deployment`

Module for deployment of the FHE model.

concrete.ml.onnx

module `concrete.ml.onnx`

ONNX module.

Global Variables

onnx_impl_utils
ops_impl
onnx_utils

concrete.ml.onnx.onnx_utils

module `concrete.ml.onnx.onnx_utils`

Utils to interpret an ONNX model with numpy.

Global Variables

ATTR_TYPES
ATTR_GETTERS
ONNX_OPS_TO_NUMPY_IMPL

function `get_attribute`

Get the attribute from an ONNX AttributeProto.

Args:

attribute (onnx.AttributeProto): The attribute to retrieve the value from.

Returns:

Any: The stored attribute value.

function `get_op_name`

Construct the qualified name of the ONNX operator.

Args:

node (Any): ONNX graph node

Returns:

result (str): qualified name

function `execute_onnx_with_numpy`

Execute the provided ONNX graph on the given inputs.

Args:

graph (onnx.GraphProto): The ONNX graph to execute.
*inputs: The inputs of the graph.

Returns:

Tuple[numpy.ndarray]: The result of the graph's execution.

concrete.ml.quantization

module `concrete.ml.quantization`

Modules for quantization.

concrete.ml.sklearn

module `concrete.ml.sklearn`

Import sklearn models.

concrete.ml.sklearn.torch_module

module `concrete.ml.sklearn.torch_module`

Implement torch module.

concrete.ml.sklearn.tree_to_numpy

module `concrete.ml.sklearn.tree_to_numpy`

Implements the conversion of a tree model to a numpy function.

concrete.ml.torch

module `concrete.ml.torch`

Modules for torch to numpy conversion.

Global Variables

numpy_module

concrete.ml.torch.numpy_module

module `concrete.ml.torch.numpy_module`

A torch to numpy module.

concrete.ml.version

module `concrete.ml.version`

File to manage the version of the package.

# Without local volume:
docker run --rm -it -p 8888:8888 zamafhe/concrete-ml

# With local volume to save notebooks on host:
docker run --rm -it -p 8888:8888 -v /host/path:/data zamafhe/concrete-ml

import numpy
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from concrete.ml.sklearn import LogisticRegression

# Lets create a synthetic data-set
x, y = make_classification(n_samples=100,
    class_sep=2, n_features=4, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    x, y, test_size=0.2, random_state=42
)

# Now we train in plaintext using quantization
model = LogisticRegression(n_bits=2)
model.fit(X_train, y_train)

y_pred_clear = model.predict(X_test)

# Finally we compile and run inference on encrypted inputs!
model.compile(x)
y_pred_fhe = model.predict(X_test, execute_in_fhe=True)

print("In clear  :", y_pred_clear)
print("In FHE    :", y_pred_fhe)
print("Comparison:", (y_pred_fhe == y_pred_clear))

# Output:
#   In clear  : [0 1 0 1 0 1 0 1 1 1 0 1 1 0 1 0 0 1 1 1]
#   In FHE    : [0 1 0 1 0 1 0 1 1 1 0 1 1 0 1 0 0 1 1 1]
#   Comparison: [ True  True  True  True  True  True  True  True  True  True  True  True
#   True  True  True  True  True  True  True  True]

import numpy as np
import pandas as pd
from concrete.ml.sklearn import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# Create the data set as a Pandas dataframe
X, y = make_classification(
    n_samples=100,
    n_features=2,
    n_redundant=0,
    random_state=2,
)
X, y = pd.DataFrame(X), pd.DataFrame(y)

# Retrieve train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=42)

# Instantiate the model
model = LogisticRegression(n_bits=2)

# Fit the model
model.fit(X_train, y_train)

# Evaluate the model on the test set in clear
y_pred_clear = model.predict(X_test)

# Compile the model
model.compile(X_train.to_numpy())

# Perform the inference in FHE
# Warning: this will take a while. It is recommended to run this with a very small batch of
# examples first (e.g. N_TEST_FHE = 1)
# Note that here the encryption and decryption is done behind the scenes.
N_TEST_FHE = 1
y_pred_fhe = model.predict(X_test.head(N_TEST_FHE), execute_in_fhe=True)

# Assert that FHE predictions are the same as the clear predictions
print(f"{(y_pred_fhe == y_pred_clear[:N_TEST_FHE]).sum()} "
      f"examples over {N_TEST_FHE} have a FHE inference equal to the clear inference.")

# Output:
#  1 examples over 1 have a FHE inference equal to the clear inference

    quantized_numpy_module = compile_torch_model(
        torch_model,  # our model
        X_train,  # a representative input-set to be used for both quantization and compilation
        n_bits={"net_inputs": 5, "op_inputs": 3, "op_weights": 3, "net_outputs": 5},
        import_qat=is_qat,  # signal to the conversion function whether the network is QAT
        use_virtual_lib=True,
        configuration=COMPIL_CONFIG_VL,
    )

import numpy
from concrete.numpy.compilation import compiler

# Let's assume Quantization has been applied and we are left with integers only.
# This is essentially the work of Concrete-ML

# Some parameters (weight and bias) for our model taking a single feature
w = [2]
b = 2

# The function that implements our model
@compiler({"x": "encrypted"})
def linear_model(x):
    return w @ x + b

# A representative input-set is needed to compile the function
# (used for tracing)
n_bits_input = 2
inputset = numpy.arange(0, 2**n_bits_input).reshape(-1, 1)
circuit = linear_model.compile(inputset)

# Use the API to get the maximum bit-width in the circuit
max_bit_width = circuit.graph.maximum_integer_bit_width()
print("Max bit_width = ", max_bit_width)
# Max bit_width =  4

# Test our FHE inference
circuit.encrypt_run_decrypt(numpy.array([3]))
# 8

# Print the graph of the circuit
print(circuit)
# %0 = 2                     # ClearScalar<uint2>
# %1 = [2]                   # ClearTensor<uint2, shape=(1,)>
# %2 = x                     # EncryptedTensor<uint2, shape=(1,)>
# %3 = matmul(%1, %2)        # EncryptedScalar<uint3>
# %4 = add(%3, %0)           # EncryptedScalar<uint4>
# return %4

Quantization

Quantization is the process of constraining an input from a continuous or otherwise large set of values (such as real numbers) to a discrete set (such as integers).

This means that some accuracy in the representation is lost (e.g. a simple approach is to eliminate least-significant bits). However, in many cases in machine learning, it is possible to adapt the models to give meaningful results while using these smaller data types. This significantly reduces the number of bits necessary for intermediary results during the execution of these machine learning models.

Since FHE is currently limited to 8-bit integers, it is necessary to quantize models to make them compatible. As a general rule, the smaller the precision models, the better the FHE performance.

Overview of quantization in Concrete-ML

Quantization implemented in Concrete-ML is applied in two ways:

Built-in models apply quantization internally and the user only needs to configure some quantization parameters. This approach requires little work by the user but may not be a one-size-fits-all solution for all types of models. The final quantized model is FHE friendly and ready to predict over encrypted data. In this setting, Post-Training Quantization (PTQ) is for linear models, data quantization is used for tree-based models and, finally, Quantization Aware Training (QAT) is included in the built-in neural network models.
For custom neural networks with more complex topology, obtaining FHE-compatible models with good accuracy requires QAT. Concrete-ML offers the possibility for the user to perform quantization before compiling to FHE. This can be achieved through a third-party library that offers QAT tools, such as for PyTorch. In this approach, the user is responsible for implementing a full-integer model, respecting FHE constraints. Please refer to the for tips on designing FHE neural networks.

While Concrete-ML quantizes machine learning models, the data the client has is often in floating point. The Concrete-ML models provide APIs to quantize inputs and de-quantize outputs.

Please note that the floating point input is quantized in the clear, i.e. it is converted to integers before being encrypted. Moreover, the model's output are also integers and are decrypted before de-quantization.

Basics of quantization

Let be the range of a value to quantize where is the minimum and is the maximum. To quantize a range of floating point values (in ) to integer values (in ), the first step is to choose the data type that is going to be used. Concrete, the framework used by Concrete-ML, is currently limited to 8-bit integers, so this will be the value used in this example. Knowing the number of bits that can be used for a value in the range , the scale can be computed :

where is the number of bits (). For the sake of example, let's take .

In practice, the quantization scale is then . This means the gap between consecutive representable values cannot be smaller than , which, in turn, means there can be a substantial loss of precision. Every interval of length will be represented by a value within the range .

The other important parameter from this quantization schema is the zero point value. This essentially brings the 0 floating point value to a specific integer. If the quantization scheme is asymmetric (quantized values are not centered in 0), the resulting integer will be in .

When using quantized values in a matrix multiplication or convolution, the equations for computing the result become more complex. The IntelLabs distiller quantization documentation provides a more of the maths used to quantize values and how to keep computations consistent.

Configuring model quantization parameters

Built-in models provide a simple interface for configuring quantization parameters, most notably the number of bits used for inputs, model weights, intermediary and output values.

For , the quantization is done post-training. Thus, the model is trained in floating point, and then, the best integer weight representations are found, depending on the distribution of inputs and weights. For these models, the user can select the value of the n_bits parameter.

For linear models, n_bits is used to quantize both model inputs and weights. Depending on the number of features, you can use a single integer value for the n_bits parameter, e.g. a value between 2 and 7. When the number of features is high, the n_bits parameter should be decreased if you encounter compilation errors. It is also possible to quantize inputs and weights with different number of bits by passing a dictionary to n_bits , containing the op_inputs and op_weights keys.

For , the training and test data is quantized. The maximum accumulator bit-width for a model trained with n_bits=n for this type of model is known beforehand: it will need n+1 bits. Thus, as Concrete-ML only supports up to 8-bit integers, n should be less than 8. Through experimentation, it was determined that in many cases a value of 5 or 6 bits gives the same accuracy as training in floating point.

Tree-based models can directly control the accumulator bit-width used. However, if 6 or 7 bits are not sufficient to obtain good accuracy on your data-set, one option is to use an ensemble model (RandomForest or XGBoost) and increase the number of trees in the ensemble. This, however, will have a detrimental impact on FHE execution speed.

For the built-in , several linear layers are used. Thus, the outputs of a layer are used as inputs to a new layer. Built-in neural networks use Quantization Aware Training. The parameters controlling the maximum accumulator bit-width are the number of weights and activation bits ( module__n_w_bits, module__n_a_bits ), but also the pruning factor. This factor is determined automatically by specifying a desired accumulator bit-width module__n_accum_bits and, optionally, a multiplier factor, module__n_hidden_neurons_multiplier.

Note that for the built-in linear models and neural networks, the maximum accumulator bit-width can not be precisely controlled. To use many input features and a high number of bits is beneficial for model accuracy, but it can conflict with the 8-bit accumulator constraint. Finding the best quantization parameters to maximize accuracy can only be done through experimentation.

Quantizing model inputs and outputs

The models implemented in Concrete-ML provide features to let the user quantize the input data and de-quantize the output data.

In a client/server setting, the client is responsible for quantizing inputs before sending them, encrypted, to the server. Further, the client must de-quantize the encrypted integer results received from the server. See the section for more details.

Here is a simple example showing how to perform inference, starting from float values and ending up with float values. Note that the FHE engine that is compiled for the ML models does not support data batching.

Resources

IntelLabs distiller explanation of quantization:

import onnx
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

from concrete.ml.sklearn import LogisticRegression

# Create the data for classification
x, y = make_classification(n_samples=100, class_sep=2, n_features=4, random_state=42)

# Retrieve train and test sets
X_train, X_test, y_train, y_test = train_test_split(
    x, y, test_size=10, random_state=42
)

# Fix the number of bits to used for quantization
model = LogisticRegression(n_bits=2)

# Fit the model
model.fit(X_train, y_train)

# Access to the model
onnx_model = model.onnx_model

# Print the model
print(onnx.helper.printable_graph(onnx_model.graph))

# Save the model
onnx.save(onnx_model, "tmp.onnx")

# And then visualize it with Netron

# Assume quantized_module : QuantizedModule
#        data: numpy.ndarray of float

# Quantization is done in the clear
x_test_q = quantized_module.quantize_input(data)

for i in range(x_test_q.shape[0]):
    # Inputs must have size (1 x N) or (1 x C x H x W), we add the batch dimension with N=1
    x_q = np.expand_dims(x_test_q[i, :], 0)

    # Execute the model in FHE
    out_fhe = quantized_module.forward_fhe.encrypt_run_decrypt(x_q)

    # Dequantization is done in the clear
    output = quantized_module.dequantize_output(out_fhe)

    # For classifiers with multi-class outputs, the arg max is done in the clear
    y_pred = np.argmax(output, 1)

fail_if_not_found

External Libraries

Hummingbird

Hummingbird is a third-party, open-source library that converts machine learning models into tensor computations, and it can export these models to ONNX. The list of supported models can be found in the Hummingbird documentation.

Concrete-ML allows the conversion of an ONNX inference to NumPy inference (note that NumPy is always the entry point to run models in FHE with Concrete ML).

Hummingbird exposes a convert function that can be imported as follows from the hummingbird.ml package:

This function can be used to convert a machine learning model to an ONNX as follows:

In theory, the resulting onnx_model could be used directly within Concrete-ML's get_equivalent_numpy_forward method (as long as all operators present in the ONNX model are implemented in NumPy) and get the NumPy inference.

In practice, there are some steps needed to clean the ONNX output and make the graph compatible with Concrete-ML, such as applying quantization where needed or deleting/replacing non-FHE friendly ONNX operators (such as Softmax and ArgMax).

Skorch

Concrete-ML uses to implement multi-layer, fully-connected PyTorch neural networks in a way that is compatible with the Scikit-learn API.

This wrapper implements Torch training boilerplate code, alleviating the work that needs to be done by the user. It is possible to add hooks during the training phase, for example once an epoch is finished.

Skorch allows the user to easily create a classifier or regressor around a neural network (NN), implemented in Torch as a nn.Module, which is used by Concrete-ML to provide a fully-connected multi-layer NN with a configurable number of layers and optional pruning (see and the for more information).

Under the hood, Concrete-ML uses a Skorch wrapper around a single PyTorch module, SparseQuantNeuralNetImpl. More information can be found .

Brevitas

is a quantization aware learning toolkit built on top of PyTorch. It provides quantization layers that are one-to-one equivalents to PyTorch layers, but also contain operations that perform the quantization during training.

While Brevitas provides many types of quantization, for Concrete-ML, a custom "mixed integer" quantization applies. This "mixed integer" quantization is much simpler than the "integer only" mode of Brevitas. The "mixed integer" network design is defined as:

all weights and activations of convolutional, linear and pooling layers must be quantized (e.g. using Brevitas layers, QuantConv2D, QuantAvgPool2D, QuantLinear)
PyTorch floating point versions of univariate functions can be used. E.g. torch.relu, nn.BatchNormalization2D, torch.max

The "mixed integer" mode used in Concrete-ML neural networks is based on the that makes both weights and activations representable as integers during training. However, through the use of lookup tables in Concrete-ML, floating point univariate PyTorch functions are supported.

For "mixed integer" quantization to work, the first layer of a Brevitas nn.Module must be a QuantIdentity layer. However, you can then use functions such as torch.sigmoid on the result of such a quantizing operation.

For examples of such a "mixed integer" network design, please see the Quantization Aware Training examples:

or go to the .

You can also refer to the class which is the basis of the built-in NeuralNetworkClassifier.

Quantization tools

Quantizing data

Concrete-ML has support for quantized ML models and also provides quantization tools for Quantization Aware Training and Post-Training Quantization. The core of this functionality is the conversion of floating point values to integers and back. This is done using QuantizedArray in concrete.ml.quantization.

The QuantizedArray class takes several arguments that determine how float values are quantized:

n_bits that defines the precision of the quantization
values are floating point values that will be converted to integers
is_signed

See also the reference for more information:

It is also possible to use symmetric quantization, where the integer values are centered around 0:

In the following example, showing the de-quantization of model outputs, the QuantizedArray class is used in a different way. Here it uses pre-quantized integer values and has the scale and zero-point set explicitly. Once the QuantizedArray is constructed, calling dequant() will compute the floating point values corresponding to the integer values qvalues, which are the output of the forward_fhe.encrypt_run_decrypt(..) call.

Quantized modules

Machine learning models are implemented with a diverse set of operations, such as convolution, linear transformations, activation functions and element-wise operations. When working with quantized values, these operations cannot be carried out in an equivalent way as for floating point values. With quantization, it is necessary to re-scale the input and output values of each operation to fit in the quantization domain.

In Concrete-ML, the quantized equivalent of a scikit-learn model or a PyTorch nn.Module is the QuantizedModule. Note that only inference is implemented in the QuantizedModule, and it is built through a conversion of the inference function of the corresponding scikit-learn or PyTorch module.

Built-in neural networks expose the quantized_module member, while a QuantizedModule is also the result of the compilation of custom models through compile_torch_model and compile_brevitas_qat_model.

The quantized versions of floating point model operations are stored in the QuantizedModule. The ONNX_OPS_TO_QUANTIZED_IMPL dictionary maps ONNX floating point operators (e.g. Gemm) to their quantized equivalent (e.g. QuantizedGemm). For more information on implementing these operations, please see the .

The computation graph is taken from the corresponding floating point ONNX graph exported from scikit-learn , or from the ONNX graph exported by PyTorch. Calibration is used to obtain quantized parameters for the operations in the QuantizedModule. Parameters are also determined for the quantization of inputs during model deployment.

Calibration is the process of determining the typical distributions of values encountered for the intermediate values of a model during inference.

To perform calibration, an interpreter goes through the ONNX graph in and stores the intermediate results as it goes. The statistics of these values determine quantization parameters.

That QuantizedModule generates the Concrete-Numpy function that is compiled to FHE. The compilation will succeed if the intermediate values conform to the 8-bits precision limit of the Concrete stack. See for details.

Resources

Lei Mao's blog on quantization:
Google paper on neural network quantization and integer-only inference:

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]

__init__(
    criterion='gini',
    splitter='best',
    max_depth=None,
    min_samples_split=2,
    min_samples_leaf=1,
    min_weight_fraction_leaf=0.0,
    max_features=None,
    random_state=None,
    max_leaf_nodes=None,
    min_impurity_decrease=0.0,
    class_weight=None,
    ccp_alpha: float = 0.0,
    n_bits: int = 6
)

__init__(
    criterion='squared_error',
    splitter='best',
    max_depth=None,
    min_samples_split=2,
    min_samples_leaf=1,
    min_weight_fraction_leaf=0.0,
    max_features=None,
    random_state=None,
    max_leaf_nodes=None,
    min_impurity_decrease=0.0,
    ccp_alpha=0.0,
    n_bits: int = 6
)

torch.add

torch.exp

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression

# Instantiate the logistic regression from sklearn
lr = LogisticRegression()

# Create synthetic data
X, y = make_classification(
    n_samples=100, n_features=20, n_classes=2
)

# Fit the model
lr.fit(X, y)

# Convert the model to ONNX
onnx_model = convert(lr, backend="onnx", test_input=X).model

import torch.nn as nn

class QATnetwork(nn.Module):
    def __init__(self):
        super(QATnetwork, self).__init__()
        self.quant_inp = qnn.QuantIdentity(
            bit_width=4, return_quant_tensor=True)
        # ...

    def forward(self, x):
        out = self.quant_inp(x)
        return torch.sigmoid(out)
        # ...

from concrete.ml.quantization import QuantizedArray
import numpy
numpy.random.seed(0)
A = numpy.random.uniform(-2, 2, 10)
print("A = ", A)
# array([ 0.19525402,  0.86075747,  0.4110535,  0.17953273, -0.3053808,
#         0.58357645, -0.24965115,  1.567092 ,  1.85465104, -0.46623392])
q_A = QuantizedArray(7, A)
print("q_A.qvalues = ", q_A.qvalues)
# array([ 37,          73,          48,         36,          9,
#         58,          12,          112,        127,         0])
# the quantized integers values from A.
print("q_A.quantizer.scale = ", q_A.quantizer.scale)
# 0.018274684777173276, the scale S.
print("q_A.quantizer.zero_point = ", q_A.quantizer.zero_point)
# 26, the zero point Z.
print("q_A.dequant() = ", q_A.dequant())
# array([ 0.20102153,  0.85891018,  0.40204307,  0.18274685, -0.31066964,
#         0.58478991, -0.25584559,  1.57162289,  1.84574316, -0.4751418 ])
# Dequantized values.

q_A = QuantizedArray(3, A)
print("Unsigned: q_A.qvalues = ", q_A.qvalues)
print("q_A.quantizer.zero_point = ", q_A.quantizer.zero_point)
# Unsigned: q_A.qvalues =  [2 4 2 2 0 3 0 6 7 0]
# q_A.quantizer.zero_point =  1

q_A = QuantizedArray(3, A, is_signed=True, is_symmetric=True)
print("Signed Symmetric: q_A.qvalues = ", q_A.qvalues)
print("q_A.quantizer.zero_point = ", q_A.quantizer.zero_point)
# Signed Symmetric: q_A.qvalues =  [ 0  1  1  0  0  1  0  3  3 -1]
# q_A.quantizer.zero_point =  0

import numpy

def dequantize_output(self, qvalues: numpy.ndarray) -> numpy.ndarray:
    # .....
    # Assume: qvalues is the decrypted integer output of the model
    # .....
    QuantizedArray(
            output_layer.n_bits,
            qvalues,
            value_is_float=False,
            scale=output_layer.output_scale,
            zero_point=output_layer.output_zero_point,
        ).dequant()
    # ....

from sklearn.datasets import fetch_openml, make_circles
from concrete.ml.sklearn import RandomForestClassifier
from concrete.numpy import Configuration
debug_config = Configuration(
    enable_unsafe_features=True,
    use_insecure_key_cache=True,
    insecure_key_cache_location="~/.cml_keycache",
)

n_bits = 2
X, y = make_circles(n_samples=1000, noise=0.1, factor=0.6, random_state=0)
concrete_clf = RandomForestClassifier(
    n_bits=n_bits, n_estimators=10, max_depth=5
)
concrete_clf.fit(X, y)

concrete_clf.compile(X, debug_config, use_virtual_lib=True)

y_preds_clear = concrete_clf.predict(X)

import numpy
import torch

from torch import nn
from concrete.ml.torch.compile import compile_torch_model

N_FEAT = 2
class SimpleNet(nn.Module):
    """Simple MLP with PyTorch"""

    def __init__(self, n_hidden=30):
        super().__init__()
        self.fc1 = nn.Linear(in_features=N_FEAT, out_features=n_hidden)
        self.fc2 = nn.Linear(in_features=n_hidden, out_features=n_hidden)
        self.fc3 = nn.Linear(in_features=n_hidden, out_features=2)


    def forward(self, x):
        """Forward pass."""
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x


torch_input = torch.randn(100, N_FEAT)
torch_model = SimpleNet(120)
try:
    quantized_numpy_module = compile_torch_model(
        torch_model,
        torch_input,
        n_bits = 3,
    )
except RuntimeError as err:
    print(err)

%0 = [[-1 -3] [ ... ] [-2  2]]        # ClearTensor<int3, shape=(120, 2)>
 %1 = [[ 1  3 -2 ...  1  2  0]]        # ClearTensor<int3, shape=(120, 120)>
 %2 = [[ 2  0  3 ... -2 -2 -1]]        # ClearTensor<int3, shape=(2, 120)>
 %3 = _onnx__Gemm_0                    # EncryptedTensor<uint5, shape=(1, 2)>
 %4 = -15                              # ClearScalar<int5>
 %5 = add(%3, %4)                      # EncryptedTensor<int6, shape=(1, 2)>
 %6 = subgraph(%5)                     # EncryptedTensor<int3, shape=(1, 2)>
 %7 = matmul(%6, %2)                   # EncryptedTensor<int6, shape=(1, 120)>
 %8 = subgraph(%7)                     # EncryptedTensor<uint3, shape=(1, 120)>
 %9 = matmul(%8, %1)                   # EncryptedTensor<int9, shape=(1, 120)>
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ only up to 8-bit integers are supported
%10 = subgraph(%9)                     # EncryptedTensor<uint3, shape=(1, 120)>
%11 = matmul(%10, %0)                  # EncryptedTensor<int8, shape=(1, 2)>
%12 = subgraph(%11)                    # EncryptedTensor<uint5, shape=(1, 2)>
return %12

%0 = [[-1 -3] [ ... ] [-2  2]]        # ClearTensor<int3, shape=(120, 2)>
 %1 = [[ 1  3 -2 ...  1  2  0]]        # ClearTensor<int3, shape=(120, 120)>
 %2 = [[ 2  0  3 ... -2 -2 -1]]        # ClearTensor<int3, shape=(2, 120)>

 %3 = _onnx__Gemm_0                    # EncryptedTensor<uint5, shape=(1, 2)>
 %4 = -15                              # ClearScalar<int5>
 %5 = add(%3, %4)                      # EncryptedTensor<int6, shape=(1, 2)>
 %6 = subgraph(%5)                     # EncryptedTensor<int3, shape=(1, 2)>

%9 = matmul(%8, %1)                   # EncryptedTensor<int9, shape=(1, 120)>
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ only up to 8-bit integers are supported
%10 = subgraph(%9)                     # EncryptedTensor<uint3, shape=(1, 120)>

torch_model = SimpleNet(50)
try:
    quantized_numpy_module = compile_torch_model(
        torch_model,
        torch_input,
        n_bits = 3,
        show_mlir=True,
    )
except RuntimeError as err:
    print(err)

%cst = arith.constant dense<...> : tensor<50x2xi9>
%cst_0 = arith.constant dense<...>
%cst_1 = arith.constant dense<...> : tensor<2x50xi9>
%c-14_i9 = arith.constant -14 : i9
%c128_i9 = arith.constant 128 : i9
%c128_i9_2 = arith.constant 128 : i9
%c128_i9_3 = arith.constant 128 : i9
%c128_i9_4 = arith.constant 128 : i9
%hack_0_c-14_i9 = tensor.from_elements %c-14_i9 : tensor<1xi9>
%0 = "FHELinalg.add_eint_int"(%arg0, %hack_0_c-14_i9) : (tensor<1x2x!FHE.eint<8>>, tensor<1xi9>) -> tensor<1x2x!FHE.eint<8>>
%hack_1_c128_i9_4 = tensor.from_elements %c128_i9_4 : tensor<1xi9>
%1 = "FHELinalg.add_eint_int"(%0, %hack_1_c128_i9_4) : (tensor<1x2x!FHE.eint<8>>, tensor<1xi9>) -> tensor<1x2x!FHE.eint<8>>
%cst_5 = arith.constant dense<...> : tensor<256xi64>
%2 = "FHELinalg.apply_lookup_table"(%1, %cst_5) : (tensor<1x2x!FHE.eint<8>>, tensor<256xi64>) -> tensor<1x2x!FHE.eint<8>>

%3 = "FHELinalg.matmul_eint_int"(%2, %cst_1) : (tensor<1x2x!FHE.eint<8>>, tensor<2x50xi9>) -> tensor<1x50x!FHE.eint<8>>
%hack_4_c128_i9_3 = tensor.from_elements %c128_i9_3 : tensor<1xi9>
%4 = "FHELinalg.add_eint_int"(%3, %hack_4_c128_i9_3) : (tensor<1x50x!FHE.eint<8>>, tensor<1xi9>) -> tensor<1x50x!FHE.eint<8>>
%cst_6 = arith.constant dense<...> : tensor<34x256xi64>
%cst_7 = arith.constant dense<...]> : tensor<1x50xindex>
%5 = "FHELinalg.apply_mapped_lookup_table"(%4, %cst_6, %cst_7) : (tensor<1x50x!FHE.eint<8>>, tensor<34x256xi64>, tensor<1x50xindex>) -> tensor<1x50x!FHE.eint<8>>

%6 = "FHELinalg.matmul_eint_int"(%5, %cst_0) : (tensor<1x50x!FHE.eint<8>>, tensor<50x50xi9>) -> tensor<1x50x!FHE.eint<8>>
%hack_7_c128_i9_2 = tensor.from_elements %c128_i9_2 : tensor<1xi9>
%7 = "FHELinalg.add_eint_int"(%6, %hack_7_c128_i9_2) : (tensor<1x50x!FHE.eint<8>>, tensor<1xi9>) -> tensor<1x50x!FHE.eint<8>>
%cst_8 = arith.constant dense<...> : tensor<34x256xi64>
%cst_9 = arith.constant dense<...> : tensor<1x50xindex>
%8 = "FHELinalg.apply_mapped_lookup_table"(%7, %cst_8, %cst_9) : (tensor<1x50x!FHE.eint<8>>, tensor<34x256xi64>, tensor<1x50xindex>) -> tensor<1x50x!FHE.eint<8>>

%9 = "FHELinalg.matmul_eint_int"(%8, %cst) : (tensor<1x50x!FHE.eint<8>>, tensor<50x2xi9>) -> tensor<1x2x!FHE.eint<8>>
%hack_10_c128_i9 = tensor.from_elements %c128_i9 : tensor<1xi9>
%10 = "FHELinalg.add_eint_int"(%9, %hack_10_c128_i9) : (tensor<1x2x!FHE.eint<8>>, tensor<1xi9>) -> tensor<1x2x!FHE.eint<8>>
%cst_10 = arith.constant dense<...> : tensor<2x256xi64>
%cst_11 = arith.constant dense<[[0, 1]]> : tensor<1x2xindex>
%11 = "FHELinalg.apply_mapped_lookup_table"(%10, %cst_10, %cst_11) : (tensor<1x2x!FHE.eint<8>>, tensor<2x256xi64>, tensor<1x2xindex>) -> tensor<1x2x!FHE.eint<8>>
return %11 : tensor<1x2x!FHE.eint<8>>

import_qat (bool): Set to True to import a network that contains quantizers and was trained using quantization aware training

import_qat (bool): Flag to signal that the network being imported contains quantizers in in its computation graph and that Concrete ML should not requantize it.

n_bits (Union[int,dict]): the number of bits for the quantization

, then run git lfs pull.

These models use a stack of linear layers and the activation function and the number of neurons in each layer is configurable. This approach is similar to what is available in Scikit-learn using the MLPClassifier/MLPRegressor classes. The built-in, fully connected neural network (FCNN) models train easily with a single call to .fit(), which will automatically quantize the weights and activations. These models use Quantization Aware Training, allowing good performance for low precision (down to 2-3 bit) weights and activations.

concrete.ml.deployment.fhe_client_server

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

compile_torch_model(
    torch_model: Module,
    torch_inputset: Union[Tensor, ndarray, Tuple[Union[Tensor, ndarray], ]],
    import_qat: bool = False,
    configuration: Optional[Configuration] = None,
    compilation_artifacts: Optional[DebugArtifacts] = None,
    show_mlir: bool = False,
    n_bits=16,
    use_virtual_lib: bool = False,
    p_error: Optional[float] = 6.3342483999973e-05
) → QuantizedModule

compile_onnx_model(
    onnx_model: ModelProto,
    torch_inputset: Union[Tensor, ndarray, Tuple[Union[Tensor, ndarray], ]],
    import_qat: bool = False,
    configuration: Optional[Configuration] = None,
    compilation_artifacts: Optional[DebugArtifacts] = None,
    show_mlir: bool = False,
    n_bits=16,
    use_virtual_lib: bool = False,
    p_error: Optional[float] = 6.3342483999973e-05
) → QuantizedModule

compile_brevitas_qat_model(
    torch_model: Module,
    torch_inputset: Union[Tensor, ndarray, Tuple[Union[Tensor, ndarray], ]],
    n_bits: Union[int, dict],
    configuration: Optional[Configuration] = None,
    compilation_artifacts: Optional[DebugArtifacts] = None,
    show_mlir: bool = False,
    use_virtual_lib: bool = False,
    p_error: Optional[float] = 6.3342483999973e-05,
    output_onnx_file: Union[Path, str] = None
) → QuantizedModule

compile(
    q_inputs: Union[Tuple[ndarray, ], ndarray],
    configuration: Optional[Configuration] = None,
    compilation_artifacts: Optional[DebugArtifacts] = None,
    show_mlir: bool = False,
    use_virtual_lib: bool = False,
    p_error: Optional[float] = 6.3342483999973e-05
) → Circuit

# Try to install the env normally
make setup_env

# If you are still having issues, sync the environment
make sync_env

# If you are still having issues on your OS, delete the venv:
rm -rf .venv

# And re-run the env setup
make setup_env

# Try to install the env normally
make setup_env

# If you are still having issues, sync the environment
make sync_env

# If you are still having issues in Docker, delete the venv:
rm -rf ~/dev_venv/*

# Disconnect from Docker
exit

# And relaunch, the venv will be reinstalled
make docker_start

# If you are still out of luck, force a rebuild which will also delete the volumes
make docker_rebuild

# And start Docker, which will reinstall the venv
make docker_start

__init__(
    n_bits: int = 6,
    max_depth: Optional[int] = 3,
    learning_rate: Optional[float] = 0.1,
    n_estimators: Optional[int] = 20,
    objective: Optional[str] = 'binary:logistic',
    booster: Optional[str] = None,
    tree_method: Optional[str] = None,
    n_jobs: Optional[int] = None,
    gamma: Optional[float] = None,
    min_child_weight: Optional[float] = None,
    max_delta_step: Optional[float] = None,
    subsample: Optional[float] = None,
    colsample_bytree: Optional[float] = None,
    colsample_bylevel: Optional[float] = None,
    colsample_bynode: Optional[float] = None,
    reg_alpha: Optional[float] = None,
    reg_lambda: Optional[float] = None,
    scale_pos_weight: Optional[float] = None,
    base_score: Optional[float] = None,
    missing: float = nan,
    num_parallel_tree: Optional[int] = None,
    monotone_constraints: Optional[Dict[str, int], str] = None,
    interaction_constraints: Optional[str, List[Tuple[str]]] = None,
    importance_type: Optional[str] = None,
    gpu_id: Optional[int] = None,
    validate_parameters: Optional[bool] = None,
    predictor: Optional[str] = None,
    enable_categorical: bool = False,
    use_label_encoder: bool = False,
    random_state: Optional[RandomState, int] = None,
    verbosity: Optional[int] = None
)

__init__(
    n_bits: int = 6,
    max_depth: Optional[int] = 3,
    learning_rate: Optional[float] = 0.1,
    n_estimators: Optional[int] = 20,
    objective: Optional[str] = 'reg:squarederror',
    booster: Optional[str] = None,
    tree_method: Optional[str] = None,
    n_jobs: Optional[int] = None,
    gamma: Optional[float] = None,
    min_child_weight: Optional[float] = None,
    max_delta_step: Optional[float] = None,
    subsample: Optional[float] = None,
    colsample_bytree: Optional[float] = None,
    colsample_bylevel: Optional[float] = None,
    colsample_bynode: Optional[float] = None,
    reg_alpha: Optional[float] = None,
    reg_lambda: Optional[float] = None,
    scale_pos_weight: Optional[float] = None,
    base_score: Optional[float] = None,
    missing: float = nan,
    num_parallel_tree: Optional[int] = None,
    monotone_constraints: Optional[Dict[str, int], str] = None,
    interaction_constraints: Optional[str, List[Tuple[str]]] = None,
    importance_type: Optional[str] = None,
    gpu_id: Optional[int] = None,
    validate_parameters: Optional[bool] = None,
    predictor: Optional[str] = None,
    enable_categorical: bool = False,
    use_label_encoder: bool = False,
    random_state: Optional[RandomState, int] = None,
    verbosity: Optional[int] = None
)

from concrete.ml.sklearn import NeuralNetClassifier
import torch.nn as nn

n_inputs = 10
n_outputs = 2
params = {
    "module__n_layers": 2,
    "module__n_w_bits": 2,
    "module__n_a_bits": 2,
    "module__n_accum_bits": 8,
    "module__n_hidden_neurons_multiplier": 1,
    "module__n_outputs": n_outputs,
    "module__input_dim": n_inputs,
    "module__activation_function": nn.ReLU,
    "max_epochs": 10,
}

concrete_classifier = NeuralNetClassifier(**params)

__init__(
    n_bits=2,
    epsilon=0.0,
    tol=0.0001,
    C=1.0,
    loss='epsilon_insensitive',
    fit_intercept=True,
    intercept_scaling=1.0,
    dual=True,
    verbose=0,
    random_state=None,
    max_iter=1000
)

__init__(
    n_bits=2,
    penalty='l2',
    loss='squared_hinge',
    dual=True,
    tol=0.0001,
    C=1.0,
    multi_class='ovr',
    fit_intercept=True,
    intercept_scaling=1,
    class_weight=None,
    verbose=0,
    random_state=None,
    max_iter=1000
)

import numpy
from tqdm import tqdm
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

from concrete.ml.sklearn import LogisticRegression

# Create the data for classification
X, y = make_classification(
    n_features=2,
    n_redundant=0,
    n_informative=2,
    random_state=2,
    n_clusters_per_class=1,
    n_samples=100,
)

# Retrieve train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=42)

# Instantiate the model
model = LogisticRegression(n_bits=2)

# Fit the model
model.fit(X_train, y_train)

# Evaluate the model on the test set in clear
y_pred_clear = model.predict(X_test)

# Compile the model
model.compile(X_train)

# Perform the inference in FHE
# Note that here the encryption and decryption is done behind the scene.
# It is recommended to run this with a very small batch of
# examples first (e.g. N_TEST_FHE = 3)
N_TEST_FHE = 3
y_pred_fhe = numpy.array([
  model.predict([sample], execute_in_fhe=True)[0]
  for sample in tqdm(X_test[:N_TEST_FHE])
])

# Assert that FHE predictions are the same as the clear predictions
print(f"{(y_pred_fhe == y_pred_clear[:N_TEST_FHE]).sum()} "
      f"examples over {N_TEST_FHE} have a FHE inference equal to the clear inference.")

# Output:
#  3 examples over 3 have a FHE inference equal to the clear inference

Using Torch

In addition to the built-in models, Concrete-ML supports generic machine learning models implemented with Torch, or exported as ONNX graphs.

As Quantization Aware Training (QAT) is the most appropriate method of training neural networks that are compatible with FHE constraints, Concrete-ML works with Brevitas, a library providing QAT support for PyTorch.

The following example uses a simple QAT PyTorch model that implements a fully connected neural network with two hidden layers. Due to its small size, making this model respect FHE constraints is relatively easy.

Once the model is trained, calling the compile_brevitas_qat_model from Concrete-ML will automatically perform conversion and compilation of a QAT network. Here, 3-bit quantization is used for both the weights and activations.

The model can now be used to perform encrypted inference. Next, the test data is quantized:

and the encrypted inference run using either:

quantized_numpy_module.forward_and_dequant() to compute predictions in the clear, on quantized data and then de-quantize the result. The return value of this function contains the dequantized (float) output of running the model in the clear. Calling the forward function on the clear data is useful when debugging. The results in FHE will be the same as those on clear quantized data.
quantized_numpy_module.forward_fhe.encrypt_run_decrypt() to perform the FHE inference. In this case, dequantization is done in a second stage using quantized_numpy_module.dequantize_output().

Generic Quantization Aware Training import

While the example above shows how to import a Brevitas/PyTorch model, Concrete-ML also provides an option to import generic QAT models implemented either in PyTorch or through ONNX. Interestingly, deep learning models made with TensorFlow or Keras should be usable, by preliminary converting them to ONNX.

QAT models contain quantizers in the PyTorch graph. These quantizers ensure that the inputs to the Linear/Dense and Conv layers are quantized.

Suppose that n_bits_qat is the bit-width of activations and weights during the QAT process. To import a PyTorch QAT network, you can use the library function, passing import_qat=True:

Alternatively, if you want to import an ONNX model directly, please see . The also supports the import_qat parameter.

When importing QAT models using this generic pipeline, a representative calibration set should be given as quantization parameters in the model need to be inferred from the statistics of the values encountered during inference.

Supported operators and activations

Concrete-ML supports a variety of PyTorch operators that can be used to build fully connected or convolutional neural networks, with normalization and activation layers. Moreover, many element-wise operators are supported.

Operators

univariate operators

shape modifying operators

operators that take an encrypted input and unencrypted constants

Please note that Concrete-ML supports these operators but also the Quantization Aware Training equivalents from Brevitas.

brevitas.nn.QuantLinear
brevitas.nn.QuantConv2d

operators that can take both encrypted+unencrypted and encrypted+encrypted inputs

Quantizers

brevitas.nn.QuantIdentity

Activations

Note that the equivalent versions from torch.functional are also supported.

import brevitas.nn as qnn
import torch.nn as nn
import torch

N_FEAT = 12
n_bits = 3

class QATSimpleNet(nn.Module):
    def __init__(self, n_hidden):
        super().__init__()

        self.quant_inp = qnn.QuantIdentity(bit_width=n_bits, return_quant_tensor=True)
        self.fc1 = qnn.QuantLinear(N_FEAT, n_hidden, True, weight_bit_width=n_bits, bias_quant=None)
        self.quant2 = qnn.QuantIdentity(bit_width=n_bits, return_quant_tensor=True)
        self.fc2 = qnn.QuantLinear(n_hidden, n_hidden, True, weight_bit_width=3, bias_quant=None)
        self.quant3 = qnn.QuantIdentity(bit_width=n_bits, return_quant_tensor=True)
        self.fc3 = qnn.QuantLinear(n_hidden, 2, True, weight_bit_width=n_hidden, bias_quant=None)

    def forward(self, x):
        x = self.quant_inp(x)
        x = self.quant2(torch.relu(self.fc1(x)))
        x = self.quant3(torch.relu(self.fc2(x)))
        x = self.fc3(x)
        return x

from concrete.ml.torch.compile import compile_brevitas_qat_model
import numpy

torch_input = torch.randn(100, N_FEAT)
torch_model = QATSimpleNet(30)
quantized_numpy_module = compile_brevitas_qat_model(
    torch_model, # our model
    torch_input, # a representative input-set to be used for both quantization and compilation
    n_bits = n_bits,
)

from concrete.ml.torch.compile import compile_torch_model
n_bits_qat = 3

quantized_numpy_module = compile_torch_model(
    torch_model,
    torch_input,
    import_qat=True,
    n_bits=n_bits_qat,
)

import numpy
import onnx
import tensorflow
import tf2onnx

from concrete.ml.torch.compile import compile_onnx_model
from concrete.numpy.compilation import Configuration


class FC(tensorflow.keras.Model):
    """A fully-connected model."""

    def __init__(self):
        super().__init__()
        hidden_layer_size = 10
        output_size = 5

        self.dense1 = tensorflow.keras.layers.Dense(
            hidden_layer_size,
            activation=tensorflow.nn.relu,
        )
        self.dense2 = tensorflow.keras.layers.Dense(output_size, activation=tensorflow.nn.relu6)
        self.flatten = tensorflow.keras.layers.Flatten()

    def call(self, inputs):
        """Forward function."""
        x = self.flatten(inputs)
        x = self.dense1(x)
        x = self.dense2(x)
        return self.flatten(x)


n_bits = 6
input_output_feature = 2
input_shape = (input_output_feature,)
num_inputs = 1
n_examples = 5000

# Define the Keras model
keras_model = FC()
keras_model.build((None,) + input_shape)
keras_model.compute_output_shape(input_shape=(None, input_output_feature))

# Create random input
input_set = numpy.random.uniform(-100, 100, size=(n_examples, *input_shape))

# Convert to ONNX
tf2onnx.convert.from_keras(keras_model, opset=14, output_path="tmp.model.onnx")

onnx_model = onnx.load("tmp.model.onnx")
onnx.checker.check_model(onnx_model)

# Compile
quantized_numpy_module = compile_onnx_model(
    onnx_model, input_set, n_bits=2
)

# Create test data from the same distribution and quantize using
# learned quantization parameters during compilation
x_test = tuple(numpy.random.uniform(-100, 100, size=(1, *input_shape)) for _ in range(num_inputs))
qtest = quantized_numpy_module.quantize_input(x_test)

y_clear = quantized_numpy_module(*qtest)
y_fhe = quantized_numpy_module.forward_fhe.encrypt_run_decrypt(*qtest)

print("Execution in clear: ", y_clear)
print("Execution in FHE:   ", y_fhe)
print("Equality:           ", numpy.sum(y_clear == y_fhe), "over", numpy.size(y_fhe), "values")

concrete.ml.quantization.base_quantized_op

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

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

method `init`

property op_type

Get the type of this operation.

Returns:

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

method `calibrate`

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 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`

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`

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`

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`

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`

property op_type

Get the type of this operation.

Returns:

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

method `calibrate`

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 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`

Determine if this op can be fused.

This operation can be fused and computed in float when a single integer tensor generates both the operands. For example in the formula: f(x) = x || (x + 1) where x is an integer tensor.

Returns:

bool: Can fuse

classmethod `must_quantize_input`

Determine if an input must be quantized.

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`

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`

Execute the quantized forward.

Args:

*q_inputs (QuantizedArray): Quantized inputs.
**attrs: the QuantizedOp attributes.

Returns:

QuantizedArray: The returned quantized value.

from concrete.ml.quantization import QuantizedArray

def q_impl(
    self,
    *q_inputs: QuantizedArray,
    **attrs,
) -> QuantizedArray:

    # Retrieve the quantized inputs
    prepared_inputs = self._prepare_inputs_with_constants(
        *q_inputs, calibrate=False, quantize_actual_values=True
    )

    result = (
        sum_result.astype(numpy.float32) - q_input.quantizer.zero_point
    ) * q_input.quantizer.scale

    return QuantizedArray(
        self.n_bits,
        result,
        value_is_float=True,
        options=self.input_quant_opts,
        stats=self.output_quant_stats,
        params=self.output_quant_params,
    )

def q_impl(
    self,
    *q_inputs: QuantizedArray,
    **attrs,
) -> QuantizedArray:

    execute_in_float = len(self.constant_inputs) > 0 or self.can_fuse()

    # a floating point implementation that can fuse
    if execute_in_float:
        prepared_inputs = self._prepare_inputs_with_constants(
            *q_inputs, calibrate=False, quantize_actual_values=False
        )

        result = prepared_inputs[0] + self.b_sign * prepared_inputs[1]
        return QuantizedArray(
            self.n_bits,
            result,
            # ......
        )
    else:
        prepared_inputs = self._prepare_inputs_with_constants(
            *q_inputs, calibrate=False, quantize_actual_values=True
        )
        # an integer implementation follows, see Case 2
        # ....

from sklearn.datasets import load_breast_cancer
from sklearn.decomposition import PCA
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

from concrete.ml.sklearn.xgb import XGBClassifier


# Get data-set and split into train and test
X, y = load_breast_cancer(return_X_y=True)

# Split the train and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# Define our model
model = XGBClassifier(n_jobs=1, n_bits=3)

# Define the pipeline
# We will normalize the data and apply a PCA before fitting the model
pipeline = Pipeline(
    [("standard_scaler", StandardScaler()), ("pca", PCA(random_state=0)), ("model", model)]
)

# Define the parameters to tune
param_grid = {
    "pca__n_components": [2, 5, 10, 15],
    "model__max_depth": [2, 3, 5],
    "model__n_estimators": [5, 10, 20],
}

# Instantiate the grid search with 5-fold cross validation on all available cores
grid = GridSearchCV(pipeline, param_grid, cv=5, n_jobs=-1, scoring="accuracy")

# Launch the grid search
grid.fit(X_train, y_train)

# Print the best parameters found
print(f"Best parameters found: {grid.best_params_}")

# Output:
#  Best parameters found: {'model__max_depth': 5, 'model__n_estimators': 10, 'pca__n_components': 5}

# Currently we only focus on model inference in FHE
# The data transformation will be done in clear (client machine)
# while the model inference will be done in FHE on a server.
# The pipeline can be split into 2 parts:
#   1. data transformation
#   2. estimator
best_pipeline = grid.best_estimator_
data_transformation_pipeline = best_pipeline[:-1]
model = best_pipeline[-1]

# Transform test set
X_train_transformed = data_transformation_pipeline.transform(X_train)
X_test_transformed = data_transformation_pipeline.transform(X_test)

# Evaluate the model on the test set in clear
y_pred_clear = model.predict(X_test_transformed)
print(f"Test accuracy in clear: {(y_pred_clear == y_test).mean():0.2f}")

# Output:
#  Test accuracy: 0.98

# Compile the model to FHE
model.compile(X_train_transformed)

# Perform the inference in FHE
# Warning: this will take a while. It is recommended to run this with a very small batch of
# example first (e.g. N_TEST_FHE = 1)
# Note that here the encryption and decryption is done behind the scene.
N_TEST_FHE = 1
y_pred_fhe = model.predict(X_test_transformed[:N_TEST_FHE], execute_in_fhe=True)

# Assert that FHE predictions are the same as the clear predictions
print(f"{(y_pred_fhe == y_pred_clear[:N_TEST_FHE]).sum()} "
      f"examples over {N_TEST_FHE} have a FHE inference equal to the clear inference.")

# Output:
#  1 examples over 1 have a FHE inference equal to the clear inference

constant_inputs

__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

__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

from torch import nn
import torch

N_FEAT = 2
class SimpleNet(nn.Module):
    """Simple MLP with PyTorch"""

    def __init__(self, n_hidden=30):
        super().__init__()
        self.fc1 = nn.Linear(in_features=N_FEAT, out_features=n_hidden)
        self.fc2 = nn.Linear(in_features=n_hidden, out_features=n_hidden)
        self.fc3 = nn.Linear(in_features=n_hidden, out_features=2)


    def forward(self, x):
        """Forward pass."""
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

import torch.nn.utils.prune as prune

class PrunedSimpleNet(SimpleNet):
    """Simple MLP with PyTorch"""

    def prune(self, max_non_zero, enable):
        # Linear layer weight has dimensions NumOutputs x NumInputs
        for layer in self.named_modules():
            if isinstance(layer, nn.Linear):
                num_zero_weights = (layer.weight.shape[1] - max_non_zero) * layer.weight.shape[0]
                if num_zero_weights <= 0:
                    continue

                if enable:
                    prune.l1_unstructured(layer, "weight", amount=num_zero_weights)
                else:
                    prune.remove(layer, "weight")

import brevitas.nn as qnn


from brevitas.core.bit_width import BitWidthImplType
from brevitas.core.quant import QuantType
from brevitas.core.restrict_val import FloatToIntImplType, RestrictValueType
from brevitas.core.scaling import ScalingImplType
from brevitas.core.zero_point import ZeroZeroPoint
from brevitas.inject import ExtendedInjector
from brevitas.quant.solver import ActQuantSolver, WeightQuantSolver
from dependencies import value

# Configure quantization options
class CommonQuant(ExtendedInjector):
    bit_width_impl_type = BitWidthImplType.CONST
    scaling_impl_type = ScalingImplType.CONST
    restrict_scaling_type = RestrictValueType.FP
    zero_point_impl = ZeroZeroPoint
    float_to_int_impl_type = FloatToIntImplType.ROUND
    scaling_per_output_channel = False
    narrow_range = True
    signed = True

    @value
    def quant_type(bit_width):
        if bit_width is None:
            return QuantType.FP
        elif bit_width == 1:
            return QuantType.BINARY
        else:
            return QuantType.INT

# Quantization options for weights/activations
class CommonWeightQuant(CommonQuant, WeightQuantSolver):
    scaling_const = 1.0
    signed = True


class CommonActQuant(CommonQuant, ActQuantSolver):
    min_val = -1.0
    max_val = 1.0

class QATPrunedSimpleNet(nn.Module):
    def __init__(self, n_hidden):
        super(QATPrunedSimpleNet, self).__init__()

        n_bits = 3
        self.quant_inp = qnn.QuantIdentity(
            act_quant=CommonActQuant,
            bit_width=n_bits,
            return_quant_tensor=True,
        )

        self.fc1 = qnn.QuantLinear(
            N_FEAT,
            n_hidden,
            True,
            weight_quant=CommonWeightQuant,
            weight_bit_width=n_bits,
            bias_quant=None,
        )

        self.q1 = qnn.QuantIdentity(
            act_quant=CommonActQuant, bit_width=n_bits, return_quant_tensor=True
        )

        self.fc2 = qnn.QuantLinear(
            n_hidden,
            n_hidden,
            True,
            weight_quant=CommonWeightQuant,
            weight_bit_width=3,
            bias_quant=None
        )

        self.q2 = qnn.QuantIdentity(
            act_quant=CommonActQuant, bit_width=n_bits, return_quant_tensor=True
        )

        self.fc3 = qnn.QuantLinear(
            n_hidden,
            2,
            True,
            weight_quant=CommonWeightQuant,
            weight_bit_width=n_hidden,
            bias_quant=None,
        )

        for m in self.modules():
            if isinstance(m, qnn.QuantLinear):
                torch.nn.init.uniform_(m.weight.data, -1, 1)

    def forward(self, x):
        x = self.quant_inp(x)
        x = self.q1(torch.relu(self.fc1(x)))
        x = self.q2(torch.relu(self.fc2(x)))
        x = self.fc3(x)
        return x

    def prune(self, max_non_zero, enable):
        # Linear layer weight has dimensions NumOutputs x NumInputs
        for name, layer in self.named_modules():
            if isinstance(layer, nn.Linear):
                num_zero_weights = (layer.weight.shape[1] - max_non_zero) * layer.weight.shape[0]
                if num_zero_weights <= 0:
                    continue

                if enable:
                    print(f"Pruning layer {name} factor {num_zero_weights}")
                    prune.l1_unstructured(layer, "weight", amount=num_zero_weights)
                else:
                    prune.remove(layer, "weight")

concrete.ml.sklearn.linear_model

module `concrete.ml.sklearn.linear_model`

Implement sklearn linear model.

class `LinearRegression`

A linear regression model with FHE.

Arguments:

n_bits (int): default is 2.
use_sum_workaround (bool): indicate if the sum workaround should be used or not. This

For more details on LinearRegression please refer to the scikit-learn documentation: https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html

method `init`

property fhe_circuit

Get the FHE circuit.

Returns:

Circuit: the FHE circuit

property input_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

onnx.ModelProto: the ONNX model

property output_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property quantize_input

Get the input quantization function.

Returns:

Callable : function that quantizes the input

method `fit`

Fit the FHE linear model.

Args:

X : training data By default, you should be able to pass: * numpy arrays * torch tensors * pandas DataFrame or Series
y (numpy.ndarray): The target data.

Returns: Any

class `ElasticNet`

An ElasticNet regression model with FHE.

Arguments:

n_bits (int): default is 2.

For more details on ElasticNet please refer to the scikit-learn documentation: https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.ElasticNet.html

method `init`

property fhe_circuit

Get the FHE circuit.

Returns:

Circuit: the FHE circuit

property input_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

onnx.ModelProto: the ONNX model

property output_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property quantize_input

Get the input quantization function.

Returns:

Callable : function that quantizes the input

class `Lasso`

A Lasso regression model with FHE.

Arguments:

n_bits (int): default is 2.

For more details on Lasso please refer to the scikit-learn documentation: https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Lasso.html

method `init`

property fhe_circuit

Get the FHE circuit.

Returns:

Circuit: the FHE circuit

property input_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

onnx.ModelProto: the ONNX model

property output_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property quantize_input

Get the input quantization function.

Returns:

Callable : function that quantizes the input

class `Ridge`

A Ridge regression model with FHE.

Arguments:

n_bits (int): default is 2.

For more details on Ridge please refer to the scikit-learn documentation: https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html

method `init`

property fhe_circuit

Get the FHE circuit.

Returns:

Circuit: the FHE circuit

property input_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

onnx.ModelProto: the ONNX model

property output_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property quantize_input

Get the input quantization function.

Returns:

Callable : function that quantizes the input

class `LogisticRegression`

A logistic regression model with FHE.

Arguments:

n_bits (int): default is 2.

For more details on LogisticRegression please refer to the scikit-learn documentation: https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html

method `init`

property fhe_circuit

Get the FHE circuit.

Returns:

Circuit: the FHE circuit

property input_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

onnx.ModelProto: the ONNX model

property output_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property quantize_input

Get the input quantization function.

Returns:

Callable : function that quantizes the input

__init__(
    n_bits: 'Union[int, dict]' = 2,
    alpha: 'float' = 1.0,
    fit_intercept: 'bool' = True,
    max_iter: 'int' = 100,
    tol: 'float' = 0.0001,
    warm_start: 'bool' = False,
    verbose: 'int' = 0
)

__init__(
    n_bits: 'Union[int, dict]' = 2,
    alpha: 'float' = 1.0,
    fit_intercept: 'bool' = True,
    max_iter: 'int' = 100,
    tol: 'float' = 0.0001,
    warm_start: 'bool' = False,
    verbose: 'int' = 0
)

__init__(
    n_bits: 'Union[int, dict]' = 2,
    power: 'float' = 0.0,
    alpha: 'float' = 1.0,
    fit_intercept: 'bool' = True,
    link: 'str' = 'auto',
    max_iter: 'int' = 100,
    tol: 'float' = 0.0001,
    warm_start: 'bool' = False,
    verbose: 'int' = 0
)

__init__(
    n_bits: int = 6,
    n_estimators=20,
    criterion='gini',
    max_depth=4,
    min_samples_split=2,
    min_samples_leaf=1,
    min_weight_fraction_leaf=0.0,
    max_features='sqrt',
    max_leaf_nodes=None,
    min_impurity_decrease=0.0,
    bootstrap=True,
    oob_score=False,
    n_jobs=None,
    random_state=None,
    verbose=0,
    warm_start=False,
    class_weight=None,
    ccp_alpha=0.0,
    max_samples=None
)

__init__(
    n_bits: int = 6,
    n_estimators=20,
    criterion='squared_error',
    max_depth=4,
    min_samples_split=2,
    min_samples_leaf=1,
    min_weight_fraction_leaf=0.0,
    max_features='sqrt',
    max_leaf_nodes=None,
    min_impurity_decrease=0.0,
    bootstrap=True,
    oob_score=False,
    n_jobs=None,
    random_state=None,
    verbose=0,
    warm_start=False,
    ccp_alpha=0.0,
    max_samples=None
)

*args

__init__(
    n_bits=2,
    penalty='l2',
    dual=False,
    tol=0.0001,
    C=1.0,
    fit_intercept=True,
    intercept_scaling=1,
    class_weight=None,
    random_state=None,
    solver='lbfgs',
    max_iter=100,
    multi_class='auto',
    verbose=0,
    warm_start=False,
    n_jobs=None,
    l1_ratio=None
)

concrete.ml.quantization.quantizers

module `concrete.ml.quantization.quantizers`

Quantization utilities for a numpy array/tensor.

Global Variables

STABILITY_CONST

function `fill_from_kwargs`

Fill a parameter set structure from kwargs parameters.

Args:

obj: an object of type klass, if None the object is created if any of the type's members appear in the kwargs
klass: the type of object to fill

Returns:

obj: an object of type klass
kwargs: remaining parameter names and values that were not filled into obj

Raises:

TypeError: if the types of the parameters in kwargs could not be converted to the corresponding types of members of klass

class `QuantizationOptions`

Options for quantization.

Determines the number of bits for quantization and the method of quantization of the values. Signed quantization allows negative quantized values. Symmetric quantization assumes the float values are distributed symmetrically around x=0 and assigns signed values around 0 to the float values. QAT (quantization aware training) quantization assumes the values are already quantized, taking a discrete set of values, and assigns these values to integers, computing only the scale.

method `init`

property quant_options

Get a copy of the quantization parameters.

Returns:

UniformQuantizationParameters: a copy of the current quantization parameters

method `copy_opts`

Copy the options from a different structure.

Args:

opts (QuantizationOptions): structure to copy parameters from.

class `MinMaxQuantizationStats`

Calibration set statistics.

This class stores the statistics for the calibration set or for a calibration data batch. Currently we only store min/max to determine the quantization range. The min/max are computed from the calibration set.

property quant_stats

Get a copy of the calibration set statistics.

Returns:

MinMaxQuantizationStats: a copy of the current quantization stats

method `check_is_uniform_quantized`

Check if these statistics correspond to uniformly quantized values.

Determines whether the values represented by this QuantizedArray show a quantized structure that allows to infer the scale of quantization.

Args:

options (QuantizationOptions): used to quantize the values in the QuantizedArray

Returns:

bool: check result.

method `compute_quantization_stats`

Compute the calibration set quantization statistics.

Args:

values (numpy.ndarray): Calibration set on which to compute statistics.

method `copy_stats`

Copy the statistics from a different structure.

Args:

stats (MinMaxQuantizationStats): structure to copy statistics from.

class `UniformQuantizationParameters`

Quantization parameters for uniform quantization.

This class stores the parameters used for quantizing real values to discrete integer values. The parameters are computed from quantization options and quantization statistics.

property quant_params

Get a copy of the quantization parameters.

Returns:

UniformQuantizationParameters: a copy of the current quantization parameters

method `compute_quantization_parameters`

Compute the quantization parameters.

Args:

options (QuantizationOptions): quantization options set
stats (MinMaxQuantizationStats): calibrated statistics for quantization

method `copy_params`

Copy the parameters from a different structure.

Args:

params (UniformQuantizationParameters): parameter structure to copy

class `UniformQuantizer`

Uniform quantizer.

Contains all information necessary for uniform quantization and provides quantization/dequantization functionality on numpy arrays.

Args:

options (QuantizationOptions): Quantization options set
stats (Optional[MinMaxQuantizationStats]): Quantization batch statistics set

method `init`

property quant_options

Get a copy of the quantization parameters.

Returns:

UniformQuantizationParameters: a copy of the current quantization parameters

property quant_params

Get a copy of the quantization parameters.

Returns:

UniformQuantizationParameters: a copy of the current quantization parameters

property quant_stats

Get a copy of the calibration set statistics.

Returns:

MinMaxQuantizationStats: a copy of the current quantization stats

method `check_is_uniform_quantized`

Check if these statistics correspond to uniformly quantized values.

Determines whether the values represented by this QuantizedArray show a quantized structure that allows to infer the scale of quantization.

Args:

options (QuantizationOptions): used to quantize the values in the QuantizedArray

Returns:

bool: check result.

method `compute_quantization_parameters`

Compute the quantization parameters.

Args:

options (QuantizationOptions): quantization options set
stats (MinMaxQuantizationStats): calibrated statistics for quantization

method `compute_quantization_stats`

Compute the calibration set quantization statistics.

Args:

values (numpy.ndarray): Calibration set on which to compute statistics.

method `copy_opts`

Copy the options from a different structure.

Args:

opts (QuantizationOptions): structure to copy parameters from.

method `copy_params`

Copy the parameters from a different structure.

Args:

params (UniformQuantizationParameters): parameter structure to copy

method `copy_stats`

Copy the statistics from a different structure.

Args:

stats (MinMaxQuantizationStats): structure to copy statistics from.

method `dequant`

Dequantize values.

Args:

qvalues (numpy.ndarray): integer values to dequantize

Returns:

numpy.ndarray: Dequantized float values.

method `quant`

Quantize values.

Args:

values (numpy.ndarray): float values to quantize

Returns:

numpy.ndarray: Integer quantized values.

class `QuantizedArray`

Abstraction of quantized array.

Contains float values and their quantized integer counter-parts. Quantization is performed by the quantizer member object. Float and int values are kept in sync. Having both types of values is useful since quantized operators in Concrete ML graphs might need one or the other depending on how the operator works (in float or in int). Moreover, when the encrypted function needs to return a value, it must return integer values.

See https://arxiv.org/abs/1712.05877.

Args:

values (numpy.ndarray): Values to be quantized.
n_bits (int): The number of bits to use for quantization.

method `init`

method `dequant`

Dequantize self.qvalues.

Returns:

numpy.ndarray: Dequantized values.

method `quant`

Quantize self.values.

Returns:

numpy.ndarray: Quantized values.

method `update_quantized_values`

Update qvalues to get their corresponding values using the related quantized parameters.

Args:

qvalues (numpy.ndarray): Values to replace self.qvalues

Returns:

values (numpy.ndarray): Corresponding values

method `update_values`

Update values to get their corresponding qvalues using the related quantized parameters.

Args:

values (numpy.ndarray): Values to replace self.values

Returns:

qvalues (numpy.ndarray): Corresponding qvalues

kwargs

params

__init__(
    n_bits,
    values: Optional[ndarray],
    value_is_float: bool = True,
    options: QuantizationOptions = None,
    stats: Optional[MinMaxQuantizationStats] = None,
    params: Optional[UniformQuantizationParameters] = None,
    **kwargs
)

concrete.ml.sklearn.protocols

module `concrete.ml.sklearn.protocols`

Protocols.

Protocols are used to mix type hinting with duck-typing. Indeed we don't always want to have an abstract parent class between all objects. We are more interested in the behavior of such objects. Implementing a Protocol is a way to specify the behavior of objects.

To read more about Protocol please read: https://peps.python.org/pep-0544

class `Quantizer`

Quantizer Protocol.

To use to type hint a quantizer.

method `dequant`

Dequantize some values.

Args:

X (numpy.ndarray): Values to dequantize

.. # noqa: DAR202

Returns:

numpy.ndarray: Dequantized values

method `quant`

Quantize some values.

Args:

values (numpy.ndarray): Values to quantize

.. # noqa: DAR202

Returns:

numpy.ndarray: The quantized values

class `ConcreteBaseEstimatorProtocol`

A Concrete Estimator Protocol.

property onnx_model

onnx_model.

.. # noqa: DAR202

Results: onnx.ModelProto

property quantize_input

Quantize input function.

method `compile`

Compiles a model to a FHE Circuit.

Args:

X (numpy.ndarray): the dequantized dataset
configuration (Optional[Configuration]): the options for compilation

.. # noqa: DAR202

Returns:

Circuit: the compiled Circuit.

method `fit`

Initialize and fit the module.

Args:

X : training data By default, you should be able to pass: * numpy arrays * torch tensors * pandas DataFrame or Series
y (numpy.ndarray): labels associated with training data

.. # noqa: DAR202

Returns:

ConcreteBaseEstimatorProtocol: the trained estimator

method `fit_benchmark`

Fit the quantized estimator and return reference estimator.

This function returns both the quantized estimator (itself), but also a wrapper around the non-quantized trained NN. This is useful in order to compare performance between the quantized and fp32 versions of the classifier

Args:

X : training data By default, you should be able to pass: * numpy arrays * torch tensors * pandas DataFrame or Series
y (numpy.ndarray): labels associated with training data

.. # noqa: DAR202

Returns:

self: self fitted
model: underlying estimator

method `post_processing`

Post-process models predictions.

Args:

y_preds (numpy.ndarray): predicted values by model (clear-quantized)

.. # noqa: DAR202

Returns:

numpy.ndarray: the post-processed predictions

class `ConcreteBaseClassifierProtocol`

Concrete classifier protocol.

property onnx_model

onnx_model.

.. # noqa: DAR202

Results: onnx.ModelProto

property quantize_input

Quantize input function.

method `compile`

Compiles a model to a FHE Circuit.

Args:

X (numpy.ndarray): the dequantized dataset
configuration (Optional[Configuration]): the options for compilation

.. # noqa: DAR202

Returns:

Circuit: the compiled Circuit.

method `fit`

Initialize and fit the module.

Args:

X : training data By default, you should be able to pass: * numpy arrays * torch tensors * pandas DataFrame or Series
y (numpy.ndarray): labels associated with training data

.. # noqa: DAR202

Returns:

ConcreteBaseEstimatorProtocol: the trained estimator

method `fit_benchmark`

Fit the quantized estimator and return reference estimator.

Args:

X : training data By default, you should be able to pass: * numpy arrays * torch tensors * pandas DataFrame or Series
y (numpy.ndarray): labels associated with training data

.. # noqa: DAR202

Returns:

self: self fitted
model: underlying estimator

method `post_processing`

Post-process models predictions.

Args:

y_preds (numpy.ndarray): predicted values by model (clear-quantized)

.. # noqa: DAR202

Returns:

numpy.ndarray: the post-processed predictions

method `predict`

Predicts for each sample the class with highest probability.

Args:

X (numpy.ndarray): Features
execute_in_fhe (bool): Whether the inference should be done in fhe or not.

.. # noqa: DAR202

Returns: numpy.ndarray

method `predict_proba`

Predicts for each sample the probability of each class.

Args:

X (numpy.ndarray): Features
execute_in_fhe (bool): Whether the inference should be done in fhe or not.

.. # noqa: DAR202

Returns: numpy.ndarray

class `ConcreteBaseRegressorProtocol`

Concrete regressor protocol.

property onnx_model

onnx_model.

.. # noqa: DAR202

Results: onnx.ModelProto

property quantize_input

Quantize input function.

method `compile`

Compiles a model to a FHE Circuit.

Args:

X (numpy.ndarray): the dequantized dataset
configuration (Optional[Configuration]): the options for compilation

.. # noqa: DAR202

Returns:

Circuit: the compiled Circuit.

method `fit`

Initialize and fit the module.

Args:

X : training data By default, you should be able to pass: * numpy arrays * torch tensors * pandas DataFrame or Series
y (numpy.ndarray): labels associated with training data

.. # noqa: DAR202

Returns:

ConcreteBaseEstimatorProtocol: the trained estimator

method `fit_benchmark`

Fit the quantized estimator and return reference estimator.

Args:

X : training data By default, you should be able to pass: * numpy arrays * torch tensors * pandas DataFrame or Series
y (numpy.ndarray): labels associated with training data

.. # noqa: DAR202

Returns:

self: self fitted
model: underlying estimator

method `post_processing`

Post-process models predictions.

Args:

y_preds (numpy.ndarray): predicted values by model (clear-quantized)

.. # noqa: DAR202

Returns:

numpy.ndarray: the post-processed predictions

method `predict`

Predicts for each sample the expected value.

Args:

X (numpy.ndarray): Features
execute_in_fhe (bool): Whether the inference should be done in fhe or not.

.. # noqa: DAR202

Returns: numpy.ndarray

**fit_params

*args

**fit_params

*args

**fit_params

*args

compile(
    X: 'ndarray',
    configuration: 'Optional[Configuration]',
    compilation_artifacts: 'Optional[DebugArtifacts]',
    show_mlir: 'bool',
    use_virtual_lib: 'bool',
    p_error: 'float'
) → Circuit

compile(
    X: 'ndarray',
    configuration: 'Optional[Configuration]',
    compilation_artifacts: 'Optional[DebugArtifacts]',
    show_mlir: 'bool',
    use_virtual_lib: 'bool',
    p_error: 'float'
) → Circuit

compile(
    X: 'ndarray',
    configuration: 'Optional[Configuration]',
    compilation_artifacts: 'Optional[DebugArtifacts]',
    show_mlir: 'bool',
    use_virtual_lib: 'bool',
    p_error: 'float'
) → Circuit

concrete.ml.sklearn.qnn

module `concrete.ml.sklearn.qnn`

Scikit-learn interface for concrete quantized neural networks.

Global Variables

MAXIMUM_TLU_BIT_WIDTH

class `SparseQuantNeuralNetImpl`

Sparse Quantized Neural Network classifier.

This class implements an MLP that is compatible with FHE constraints. The weights and activations are quantized to low bitwidth and pruning is used to ensure accumulators do not surpass an user-provided accumulator bit-width. The number of classes and number of layers are specified by the user, as well as the breadth of the network

method `init`

Sparse Quantized Neural Network constructor.

Args:

input_dim: Number of dimensions of the input data
n_layers: Number of linear layers for this network

Raises:

ValueError: if the parameters have invalid values or the computed accumulator bitwidth is zero

method `enable_pruning`

Enable pruning in the network. Pruning must be made permanent to recover pruned weights.

Raises:

ValueError: if the quantization parameters are invalid

method `forward`

Forward pass.

Args:

x (torch.Tensor): network input

Returns:

x (torch.Tensor): network prediction

method `make_pruning_permanent`

Make the learned pruning permanent in the network.

method `max_active_neurons`

Compute the maximum number of active (non-zero weight) neurons.

The computation is done using the quantization parameters passed to the constructor. Warning: With the current quantization algorithm (asymmetric) the value returned by this function is not guaranteed to ensure FHE compatibility. For some weight distributions, weights that are 0 (which are pruned weights) will not be quantized to 0. Therefore the total number of active quantized neurons will not be equal to max_active_neurons.

Returns:

n (int): maximum number of active neurons

method `on_train_end`

Call back when training is finished, can be useful to remove training hooks.

class `QuantizedSkorchEstimatorMixin`

Mixin class that adds quantization features to Skorch NN estimators.

property base_estimator_type

Get the sklearn estimator that should be trained by the child class.

property base_module_to_compile

Get the module that should be compiled to FHE. In our case this is a torch nn.Module.

Returns:

module (nn.Module): the instantiated torch module

property fhe_circuit

Get the FHE circuit.

Returns:

Circuit: the FHE circuit

property input_quantizers

Get the input quantizers.

Returns:

List[Quantizer]: the input quantizers

property n_bits_quant

Return the number of quantization bits.

This is stored by the torch.nn.module instance and thus cannot be retrieved until this instance is created.

Returns:

n_bits (int): the number of bits to quantize the network

Raises:

ValueError: with skorch estimators, the module_ is not instantiated until .fit() is called. Thus this estimator needs to be .fit() before we get the quantization number of bits. If it is not trained we raise an exception

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

_onnx_model_ (onnx.ModelProto): the ONNX model

property output_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property quantize_input

Get the input quantization function.

Returns:

Callable : function that quantizes the input

method `get_params_for_benchmark`

Get parameters for benchmark when cloning a skorch wrapped NN.

We must remove all parameters related to the module. Skorch takes either a class or a class instance for the module parameter. We want to pass our trained model, a class instance. But for this to work, we need to remove all module related constructor params. If not, skorch will instantiate a new class instance of the same type as the passed module see skorch net.py NeuralNet::initialize_instance

Returns:

params (dict): parameters to create an equivalent fp32 sklearn estimator for benchmark

method `infer`

Perform a single inference step on a batch of data.

This method is specific to Skorch estimators.

Args:

x (torch.Tensor): A batch of the input data, produced by a Dataset
**fit_params (dict) : Additional parameters passed to the forward method of the module and to the self.train_split call.

Returns: A torch tensor with the inference results for each item in the input

method `on_train_end`

Call back when training is finished by the skorch wrapper.

Check if the underlying neural net has a callback for this event and, if so, call it.

Args:

net: estimator for which training has ended (equal to self)
X: data

class `FixedTypeSkorchNeuralNet`

A mixin with a helpful modification to a skorch estimator that fixes the module type.

method `get_params`

Get parameters for this estimator.

Args:

deep (bool): If True, will return the parameters for this estimator and contained subobjects that are estimators.
**kwargs: any additional parameters to pass to the sklearn BaseEstimator class

Returns:

params : dict, Parameter names mapped to their values.

class `NeuralNetClassifier`

Scikit-learn interface for quantized FHE compatible neural networks.

This class wraps a quantized NN implemented using our Torch tools as a scikit-learn Estimator. It uses the skorch package to handle training and scikit-learn compatibility, and adds quantization and compilation functionality. The neural network implemented by this class is a multi layer fully connected network trained with Quantization Aware Training (QAT).

The datatypes that are allowed for prediction by this wrapper are more restricted than standard scikit-learn estimators as this class needs to predict in FHE and network inference executor is the NumpyModule.

method `init`

property base_estimator_type

property base_module_to_compile

Get the module that should be compiled to FHE. In our case this is a torch nn.Module.

Returns:

module (nn.Module): the instantiated torch module

property classes_

property fhe_circuit

Get the FHE circuit.

Returns:

Circuit: the FHE circuit

property history

property input_quantizers

Get the input quantizers.

Returns:

List[Quantizer]: the input quantizers

property n_bits_quant

Return the number of quantization bits.

This is stored by the torch.nn.module instance and thus cannot be retrieved until this instance is created.

Returns:

n_bits (int): the number of bits to quantize the network

Raises:

ValueError: with skorch estimators, the module_ is not instantiated until .fit() is called. Thus this estimator needs to be .fit() before we get the quantization number of bits. If it is not trained we raise an exception

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

_onnx_model_ (onnx.ModelProto): the ONNX model

property output_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property quantize_input

Get the input quantization function.

Returns:

Callable : function that quantizes the input

method `fit`

method `get_params`

Get parameters for this estimator.

Args:

deep (bool): If True, will return the parameters for this estimator and contained subobjects that are estimators.
**kwargs: any additional parameters to pass to the sklearn BaseEstimator class

Returns:

params : dict, Parameter names mapped to their values.

method `get_params_for_benchmark`

Get parameters for benchmark when cloning a skorch wrapped NN.

Returns:

params (dict): parameters to create an equivalent fp32 sklearn estimator for benchmark

method `infer`

Perform a single inference step on a batch of data.

This method is specific to Skorch estimators.

Args:

x (torch.Tensor): A batch of the input data, produced by a Dataset
**fit_params (dict) : Additional parameters passed to the forward method of the module and to the self.train_split call.

Returns: A torch tensor with the inference results for each item in the input

method `on_train_end`

Call back when training is finished by the skorch wrapper.

Check if the underlying neural net has a callback for this event and, if so, call it.

Args:

net: estimator for which training has ended (equal to self)
X: data

method `predict`

Predict on user provided data.

Predicts using the quantized clear or FHE classifier

Args:

X : input data, a numpy array of raw values (non quantized)
execute_in_fhe : whether to execute the inference in FHE or in the clear

Returns:

y_pred : numpy ndarray with predictions

class `NeuralNetRegressor`

Scikit-learn interface for quantized FHE compatible neural networks.

method `init`

property base_estimator_type

property base_module_to_compile

Get the module that should be compiled to FHE. In our case this is a torch nn.Module.

Returns:

module (nn.Module): the instantiated torch module

property fhe_circuit

Get the FHE circuit.

Returns:

Circuit: the FHE circuit

property history

property input_quantizers

Get the input quantizers.

Returns:

List[Quantizer]: the input quantizers

property n_bits_quant

Return the number of quantization bits.

This is stored by the torch.nn.module instance and thus cannot be retrieved until this instance is created.

Returns:

n_bits (int): the number of bits to quantize the network

Raises:

ValueError: with skorch estimators, the module_ is not instantiated until .fit() is called. Thus this estimator needs to be .fit() before we get the quantization number of bits. If it is not trained we raise an exception

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

_onnx_model_ (onnx.ModelProto): the ONNX model

property output_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property quantize_input

Get the input quantization function.

Returns:

Callable : function that quantizes the input

method `fit`

method `get_params`

Get parameters for this estimator.

Args:

deep (bool): If True, will return the parameters for this estimator and contained subobjects that are estimators.
**kwargs: any additional parameters to pass to the sklearn BaseEstimator class

Returns:

params : dict, Parameter names mapped to their values.

method `get_params_for_benchmark`

Get parameters for benchmark when cloning a skorch wrapped NN.

Returns:

params (dict): parameters to create an equivalent fp32 sklearn estimator for benchmark

method `infer`

Perform a single inference step on a batch of data.

This method is specific to Skorch estimators.

Args:

x (torch.Tensor): A batch of the input data, produced by a Dataset
**fit_params (dict) : Additional parameters passed to the forward method of the module and to the self.train_split call.

Returns: A torch tensor with the inference results for each item in the input

method `on_train_end`

Call back when training is finished by the skorch wrapper.

Check if the underlying neural net has a callback for this event and, if so, call it.

Args:

net: estimator for which training has ended (equal to self)
X: data

__init__(
    input_dim,
    n_layers,
    n_outputs,
    n_hidden_neurons_multiplier=4,
    n_w_bits=3,
    n_a_bits=3,
    n_accum_bits=16,
    activation_function=<class 'torch.nn.modules.activation.ReLU'>
)

concrete.ml.sklearn.base

module `concrete.ml.sklearn.base`

Module that contains base classes for our libraries estimators.

Global Variables

DEFAULT_P_ERROR_PBS
OPSET_VERSION_FOR_ONNX_EXPORT

class `QuantizedTorchEstimatorMixin`

Mixin that provides quantization for a torch module and follows the Estimator API.

This class should be mixed in with another that provides the full Estimator API. This class only provides modifiers for .fit() (with quantization) and .predict() (optionally in FHE)

method `init`

property base_estimator_type

Get the sklearn estimator that should be trained by the child class.

property base_module_to_compile

Get the Torch module that should be compiled to FHE.

property fhe_circuit

Get the FHE circuit.

Returns:

Circuit: the FHE circuit

property input_quantizers

Get the input quantizers.

Returns:

List[Quantizer]: the input quantizers

property n_bits_quant

Get the number of quantization bits.

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

_onnx_model_ (onnx.ModelProto): the ONNX model

property output_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property quantize_input

Get the input quantization function.

Returns:

Callable : function that quantizes the input

method `compile`

Compile the model.

Args:

X (numpy.ndarray): the dequantized dataset
configuration (Optional[Configuration]): the options for compilation

Returns:

Circuit: the compiled Circuit.

Raises:

ValueError: if called before the model is trained

method `fit`

Initialize and fit the module.

If the module was already initialized, by calling fit, the module will be re-initialized (unless warm_start is True). In addition to the torch training step, this method performs quantization of the trained torch model.

Args:

X : training data By default, you should be able to pass: * numpy arrays * torch tensors * pandas DataFrame or Series
y (numpy.ndarray): labels associated with training data

Returns:

self: the trained quantized estimator

method `fit_benchmark`

Fit the quantized estimator and return reference estimator.

Args:

X : training data By default, you should be able to pass: * numpy arrays * torch tensors * pandas DataFrame or Series
y (numpy.ndarray): labels associated with training data

Returns:

self: the trained quantized estimator
fp32_model: trained raw (fp32) wrapped NN estimator

method `get_params_for_benchmark`

Get the parameters to instantiate the sklearn estimator trained by the child class.

Returns:

params (dict): dictionary with parameters that will initialize a new Estimator

method `post_processing`

Post-processing the output.

Args:

y_preds (numpy.ndarray): the output to post-process

Raises:

ValueError: if unknown post-processing function

Returns:

numpy.ndarray: the post-processed output

method `predict`

Predict on user provided data.

Predicts using the quantized clear or FHE classifier

Args:

X : input data, a numpy array of raw values (non quantized)
execute_in_fhe : whether to execute the inference in FHE or in the clear

Returns:

y_pred : numpy ndarray with predictions

method `predict_proba`

Predict on user provided data, returning probabilities.

Predicts using the quantized clear or FHE classifier

Args:

X : input data, a numpy array of raw values (non quantized)
execute_in_fhe : whether to execute the inference in FHE or in the clear

Returns:

y_pred : numpy ndarray with probabilities (if applicable)

Raises:

ValueError: if the estimator was not yet trained or compiled

class `BaseTreeEstimatorMixin`

Mixin class for tree-based estimators.

A place to share methods that are used on all tree-based estimators.

method `init`

Initialize the TreeBasedEstimatorMixin.

Args:

n_bits (int): number of bits used for quantization

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

onnx.ModelProto: the ONNX model

method `compile`

Compile the model.

Args:

X (numpy.ndarray): the dequantized dataset
configuration (Optional[Configuration]): the options for compilation

Returns:

Circuit: the compiled Circuit.

method `dequantize_output`

Dequantize the integer predictions.

Args:

y_preds (numpy.ndarray): the predictions

Returns: the dequantized predictions

method `fit_benchmark`

Fit the sklearn tree-based model and the FHE tree-based model.

Args:

X (numpy.ndarray): The input data.
y (numpy.ndarray): The target data. random_state (Optional[Union[int, numpy.random.RandomState, None]]): The random state. Defaults to None.

Returns: Tuple[ConcreteEstimators, SklearnEstimators]: The FHE and sklearn tree-based models.

method `quantize_input`

Quantize the input.

Args:

X (numpy.ndarray): the input

Returns: the quantized input

class `BaseTreeRegressorMixin`

Mixin class for tree-based regressors.

A place to share methods that are used on all tree-based regressors.

method `init`

Initialize the TreeBasedEstimatorMixin.

Args:

n_bits (int): number of bits used for quantization

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

onnx.ModelProto: the ONNX model

method `compile`

Compile the model.

Args:

X (numpy.ndarray): the dequantized dataset
configuration (Optional[Configuration]): the options for compilation

Returns:

Circuit: the compiled Circuit.

method `dequantize_output`

Dequantize the integer predictions.

Args:

y_preds (numpy.ndarray): the predictions

Returns: the dequantized predictions

method `fit`

Fit the tree-based estimator.

Args:

X : training data By default, you should be able to pass: * numpy arrays * torch tensors * pandas DataFrame or Series
y (numpy.ndarray): The target data.

Returns:

Any: The fitted model.

method `fit_benchmark`

Fit the sklearn tree-based model and the FHE tree-based model.

Args:

X (numpy.ndarray): The input data.
y (numpy.ndarray): The target data. random_state (Optional[Union[int, numpy.random.RandomState, None]]): The random state. Defaults to None.

Returns: Tuple[ConcreteEstimators, SklearnEstimators]: The FHE and sklearn tree-based models.

method `post_processing`

Apply post-processing to the predictions.

Args:

y_preds (numpy.ndarray): The predictions.

Returns:

numpy.ndarray: The post-processed predictions.

method `predict`

Predict the probability.

Args:

X (numpy.ndarray): The input data.
execute_in_fhe (bool): Whether to execute in FHE. Defaults to False.

Returns:

numpy.ndarray: The predicted probabilities.

method `quantize_input`

Quantize the input.

Args:

X (numpy.ndarray): the input

Returns: the quantized input

class `BaseTreeClassifierMixin`

Mixin class for tree-based classifiers.

A place to share methods that are used on all tree-based classifiers.

method `init`

Initialize the TreeBasedEstimatorMixin.

Args:

n_bits (int): number of bits used for quantization

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

onnx.ModelProto: the ONNX model

method `compile`

Compile the model.

Args:

X (numpy.ndarray): the dequantized dataset
configuration (Optional[Configuration]): the options for compilation

Returns:

Circuit: the compiled Circuit.

method `dequantize_output`

Dequantize the integer predictions.

Args:

y_preds (numpy.ndarray): the predictions

Returns: the dequantized predictions

method `fit`

Fit the tree-based estimator.

Args:

X : training data By default, you should be able to pass: * numpy arrays * torch tensors * pandas DataFrame or Series
y (numpy.ndarray): The target data.

Returns:

Any: The fitted model.

method `fit_benchmark`

Fit the sklearn tree-based model and the FHE tree-based model.

Args:

X (numpy.ndarray): The input data.
y (numpy.ndarray): The target data. random_state (Optional[Union[int, numpy.random.RandomState, None]]): The random state. Defaults to None.

Returns: Tuple[ConcreteEstimators, SklearnEstimators]: The FHE and sklearn tree-based models.

method `post_processing`

Apply post-processing to the predictions.

Args:

y_preds (numpy.ndarray): The predictions.

Returns:

numpy.ndarray: The post-processed predictions.

method `predict`

Predict the class with highest probability.

Args:

X (numpy.ndarray): The input data.
execute_in_fhe (bool): Whether to execute in FHE. Defaults to False.

Returns:

numpy.ndarray: The predicted target values.

method `predict_proba`

Predict the probability.

Args:

X (numpy.ndarray): The input data.
execute_in_fhe (bool): Whether to execute in FHE. Defaults to False.

Returns:

numpy.ndarray: The predicted probabilities.

method `quantize_input`

Quantize the input.

Args:

X (numpy.ndarray): the input

Returns: the quantized input

class `SklearnLinearModelMixin`

A Mixin class for sklearn linear models with FHE.

method `init`

Initialize the FHE linear model.

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 Default to 2.
*args: The arguments to pass to the sklearn linear model.

property fhe_circuit

Get the FHE circuit.

Returns:

Circuit: the FHE circuit

property input_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

onnx.ModelProto: the ONNX model

property output_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property quantize_input

Get the input quantization function.

Returns:

Callable : function that quantizes the input

method `clean_graph`

Clean the graph of the onnx model.

This will remove the Cast node in the model's onnx.graph since they have no use in quantized or FHE models.

method `compile`

Compile the FHE linear model.

Args:

X (numpy.ndarray): The input data.
configuration (Optional[Configuration]): Configuration object to use during compilation

Returns:

Circuit: the compiled Circuit.

method `fit`

Fit the FHE linear model.

Args:

X : training data By default, you should be able to pass: * numpy arrays * torch tensors * pandas DataFrame or Series
y (numpy.ndarray): The target data.

Returns: Any

method `fit_benchmark`

Fit the sklearn linear model and the FHE linear model.

Args:

X (numpy.ndarray): The input data.
y (numpy.ndarray): The target data. random_state (Optional[Union[int, numpy.random.RandomState, None]]): The random state. Defaults to None.

Returns: Tuple[SklearnLinearModelMixin, sklearn.linear_model.LinearRegression]: The FHE and sklearn LinearRegression.

method `post_processing`

Post-processing the output.

Args:

y_preds (numpy.ndarray): the output to post-process

Returns:

numpy.ndarray: the post-processed output

method `predict`

Predict on user data.

Predict on user data using either the quantized clear model, implemented with tensors, or, if execute_in_fhe is set, using the compiled FHE circuit

Args:

X (numpy.ndarray): the input data
execute_in_fhe (bool): whether to execute the inference in FHE

Returns:

numpy.ndarray: the prediction as ordinals

class `SklearnLinearClassifierMixin`

A Mixin class for sklearn linear classifiers with FHE.

method `init`

Initialize the FHE linear model.

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 Default to 2.
*args: The arguments to pass to the sklearn linear model.

property fhe_circuit

Get the FHE circuit.

Returns:

Circuit: the FHE circuit

property input_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property onnx_model

Get the ONNX model.

.. # noqa: DAR201

Returns:

onnx.ModelProto: the ONNX model

property output_quantizers

Get the input quantizers.

Returns:

List[QuantizedArray]: the input quantizers

property quantize_input

Get the input quantization function.

Returns:

Callable : function that quantizes the input

method `clean_graph`

Clean the graph of the onnx model.

Any operators following gemm, including the sigmoid, softmax and argmax operators, are removed from the graph. They will be executed in clear in the post-processing method.

method `compile`

Compile the FHE linear model.

Args:

X (numpy.ndarray): The input data.
configuration (Optional[Configuration]): Configuration object to use during compilation

Returns:

Circuit: the compiled Circuit.

method `decision_function`

Predict confidence scores for samples.

Args:

X (numpy.ndarray): Samples to predict.
execute_in_fhe (bool): If True, the inference will be executed in FHE. Default to False.

Returns:

numpy.ndarray: Confidence scores for samples.

method `fit`

Fit the FHE linear model.

Args:

X : training data By default, you should be able to pass: * numpy arrays * torch tensors * pandas DataFrame or Series
y (numpy.ndarray): The target data.

Returns: Any

method `fit_benchmark`

Fit the sklearn linear model and the FHE linear model.

Args:

X (numpy.ndarray): The input data.
y (numpy.ndarray): The target data. random_state (Optional[Union[int, numpy.random.RandomState, None]]): The random state. Defaults to None.

Returns: Tuple[SklearnLinearModelMixin, sklearn.linear_model.LinearRegression]: The FHE and sklearn LinearRegression.

method `post_processing`

Post-processing the predictions.

This step may include a dequantization of the inputs if not done previously, in particular within the client-server workflow.

Args:

y_preds (numpy.ndarray): The predictions to post-process.
already_dequantized (bool): Wether the inputs were already dequantized or not. Default to False.

Returns:

numpy.ndarray: The post-processed predictions.

method `predict`

Predict on user data.

Predict on user data using either the quantized clear model, implemented with tensors, or, if execute_in_fhe is set, using the compiled FHE circuit.

Args:

X (numpy.ndarray): Samples to predict.
execute_in_fhe (bool): If True, the inference will be executed in FHE. Default to False.

Returns:

numpy.ndarray: The prediction as ordinals.

method `predict_proba`

Predict class probabilities for samples.

Args:

X (numpy.ndarray): Samples to predict.
execute_in_fhe (bool): If True, the inference will be executed in FHE. Default to False.

Returns:

numpy.ndarray: Class probabilities for samples.

**fit_params

*args

**kwargs

*args

**kwargs

*args

compilation_artifacts

*args

compilation_artifacts

*args

compile(
    X: ndarray,
    configuration: Optional[Configuration] = None,
    compilation_artifacts: Optional[DebugArtifacts] = None,
    show_mlir: bool = False,
    use_virtual_lib: bool = False,
    p_error: Optional[float] = 6.3342483999973e-05
) → Circuit

compile(
    X: ndarray,
    configuration: Optional[Configuration] = None,
    compilation_artifacts: Optional[DebugArtifacts] = None,
    show_mlir: bool = False,
    use_virtual_lib: bool = False,
    p_error: Optional[float] = 6.3342483999973e-05
) → Circuit

compile(
    X: ndarray,
    configuration: Optional[Configuration] = None,
    compilation_artifacts: Optional[DebugArtifacts] = None,
    show_mlir: bool = False,
    use_virtual_lib: bool = False,
    p_error: Optional[float] = 6.3342483999973e-05
) → Circuit

compile(
    X: ndarray,
    configuration: Optional[Configuration] = None,
    compilation_artifacts: Optional[DebugArtifacts] = None,
    show_mlir: bool = False,
    use_virtual_lib: bool = False,
    p_error: Optional[float] = 6.3342483999973e-05
) → Circuit

compile(
    X: ndarray,
    configuration: Optional[Configuration] = None,
    compilation_artifacts: Optional[DebugArtifacts] = None,
    show_mlir: bool = False,
    use_virtual_lib: bool = False,
    p_error: Optional[float] = 6.3342483999973e-05
) → Circuit

compile(
    X: ndarray,
    configuration: Optional[Configuration] = None,
    compilation_artifacts: Optional[DebugArtifacts] = None,
    show_mlir: bool = False,
    use_virtual_lib: bool = False,
    p_error: Optional[float] = 6.3342483999973e-05
) → Circuit

concrete.ml.quantization.quantized_ops

module `concrete.ml.quantization.quantized_ops`

Quantized versions of the ONNX operators for post training quantization.

class `QuantizedSigmoid`

Quantized sigmoid op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedHardSigmoid`

Quantized HardSigmoid op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedRelu`

Quantized Relu op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedPRelu`

Quantized PRelu op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedLeakyRelu`

Quantized LeakyRelu op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedHardSwish`

Quantized Hardswish op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedElu`

Quantized Elu op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedSelu`

Quantized Selu op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedCelu`

Quantized Celu op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedClip`

Quantized clip op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedRound`

Quantized round op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedPow`

Quantized pow op.

Only works for a float constant power. This operation will be fused to a (potentially larger) TLU.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedGemm`

Quantized Gemm op.

method `init`

property op_type

Get the type of this operation.

Returns:

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

method `can_fuse`

Determine if this op can be fused.

Gemm operation can not be fused since it must be performed over integer tensors and it combines different values of the input tensors.

Returns:

bool: False, this operation can not be fused as it adds different encrypted integers

method `q_impl`

class `QuantizedMatMul`

Quantized MatMul op.

method `init`

property op_type

Get the type of this operation.

Returns:

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

method `can_fuse`

Determine if this op can be fused.

Gemm operation can not be fused since it must be performed over integer tensors and it combines different values of the input tensors.

Returns:

bool: False, this operation can not be fused as it adds different encrypted integers

method `q_impl`

class `QuantizedAdd`

Quantized Addition operator.

Can add either two variables (both encrypted) or a variable and a constant

property op_type

Get the type of this operation.

Returns:

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

method `can_fuse`

Determine if this op can be fused.

Add operation can be computed in float and fused if it operates over inputs produced by a single integer tensor. For example the expression x + x * 1.75, where x is an encrypted tensor, can be computed with a single TLU.

Returns:

bool: Whether the number of integer input tensors allows computing this op as a TLU

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

method `q_impl`

class `QuantizedReshape`

Quantized Reshape op.

property op_type

Get the type of this operation.

Returns:

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

method `q_impl`

Reshape the input integer encrypted tensor.

Args:

q_inputs: an encrypted integer tensor at index 0 and one constant shape at index 1
attrs: additional optional reshape options

Returns:

result (QuantizedArray): reshaped encrypted integer tensor

class `QuantizedConv`

Quantized Conv op.

method `init`

Construct the quantized convolution operator and retrieve parameters.

Args:

n_bits_output: number of bits for the quantization of the outputs of this operator
int_input_names: names of integer tensors that are taken as input for this operation

property op_type

Get the type of this operation.

Returns:

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

method `can_fuse`

Determine if this op can be fused.

Conv operation can not be fused since it must be performed over integer tensors and it combines different elements of the input tensors.

Returns:

bool: False, this operation can not be fused as it adds different encrypted integers

method `q_impl`

Compute the quantized convolution between two quantized tensors.

Allows an optional quantized bias.

Args:

q_inputs: input tuple, contains
x (numpy.ndarray): input data. Shape is N x C x H x W for 2d

Returns:

res (QuantizedArray): result of the quantized integer convolution

class `QuantizedAvgPool`

Quantized Average Pooling op.

method `init`

property op_type

Get the type of this operation.

Returns:

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

method `can_fuse`

Determine if this op can be fused.

Avg Pooling operation can not be fused since it must be performed over integer tensors and it combines different elements of the input tensors.

Returns:

bool: False, this operation can not be fused as it adds different encrypted integers

method `q_impl`

class `QuantizedPad`

Quantized Padding op.

method `init`

property op_type

Get the type of this operation.

Returns:

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

method `can_fuse`

Determine if this op can be fused.

Pad operation can not be fused since it must be performed over integer tensors.

Returns:

bool: False, this operation can not be fused as it is manipulates integer tensors

class `QuantizedWhere`

Where operator on quantized arrays.

Supports only constants for the results produced on the True/False branches.

method `init`

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedCast`

Cast the input to the required data type.

In FHE we only support a limited number of output types. Booleans are cast to integers.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedGreater`

Comparison operator >.

Only supports comparison with a constant.

method `init`

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedGreaterOrEqual`

Comparison operator >=.

Only supports comparison with a constant.

method `init`

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedLess`

Comparison operator <.

Only supports comparison with a constant.

method `init`

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedLessOrEqual`

Comparison operator <=.

Only supports comparison with a constant.

method `init`

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedOr`

Or operator ||.

This operation is not really working as a quantized operation. It just works when things got fused, as in e.g. Act(x) = x || (x + 42))

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedDiv`

Div operator /.

This operation is not really working as a quantized operation. It just works when things got fused, as in e.g. Act(x) = 1000 / (x + 42))

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedMul`

Multiplication operator.

Only multiplies an encrypted tensor with a float constant for now. This operation will be fused to a (potentially larger) TLU.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedSub`

Subtraction operator.

This works the same as addition on both encrypted - encrypted and on encrypted - constant.

property op_type

Get the type of this operation.

Returns:

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

method `can_fuse`

Determine if this op can be fused.

Returns:

bool: Whether the number of integer input tensors allows computing this op as a TLU

method `q_impl`

class `QuantizedBatchNormalization`

Quantized Batch normalization with encrypted input and in-the-clear normalization params.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedFlatten`

Quantized flatten for encrypted inputs.

property op_type

Get the type of this operation.

Returns:

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

method `can_fuse`

Determine if this op can be fused.

Flatten operation can not be fused since it must be performed over integer tensors.

Returns:

bool: False, this operation can not be fused as it is manipulates integer tensors.

method `q_impl`

Flatten the input integer encrypted tensor.

Args:

q_inputs: an encrypted integer tensor at index 0
attrs: contains axis attribute

Returns:

result (QuantizedArray): reshaped encrypted integer tensor

class `QuantizedReduceSum`

ReduceSum with encrypted input.

This operator is currently an experimental feature.

method `init`

Construct the quantized ReduceSum operator and retrieve parameters.

Args:

n_bits_output (int): Number of bits for the operator's quantization of outputs.
int_input_names (Optional[Set[str]]): Names of input integer tensors. Default to 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`

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 `q_impl`

Sum the encrypted tensor's values over axis 1.

Args:

q_inputs (QuantizedArray): An encrypted integer tensor at index 0.
attrs (Dict): Contains axis attribute.

Returns:

(QuantizedArray): The sum of all values along axis 1 as an encrypted integer tensor.

method `tree_sum`

Large sum without overflow (only MSB remains).

Args:

input_qarray: Enctyped integer tensor.
is_calibration: Whether we are calibrating the tree sum. If so, it will create all the quantizers for the downscaling.

Returns:

(numpy.ndarray): The MSB (based on the precision self.n_bits) of the integers sum.

class `QuantizedErf`

Quantized erf op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedNot`

Quantized Not op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedBrevitasQuant`

Brevitas uniform quantization with encrypted input.

method `init`

Construct the Brevitas quantization operator.

Args:

n_bits_output (int): Number of bits for the operator's quantization of outputs. Not used, will be overridden by the bit_width in ONNX
int_input_names (Optional[Set[str]]): Names of input integer tensors. Default to None.

property op_type

Get the type of this operation.

Returns:

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

method `q_impl`

Quantize values.

Args:

q_inputs: an encrypted integer tensor at index 0 and one constant shape at index 1
attrs: additional optional reshape options

Returns:

result (QuantizedArray): reshaped encrypted integer tensor

class `QuantizedTranspose`

Transpose operator for quantized inputs.

This operator performs quantization, transposes the encrypted data, then dequantizes again.

property op_type

Get the type of this operation.

Returns:

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

method `q_impl`

Reshape the input integer encrypted tensor.

Args:

q_inputs: an encrypted integer tensor at index 0 and one constant shape at index 1
attrs: additional optional reshape options

Returns:

result (QuantizedArray): reshaped encrypted integer tensor

class `QuantizedFloor`

Quantized Floor op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedMax`

Quantized Max op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedMin`

Quantized Min op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedNeg`

Quantized Neg op.

property op_type

Get the type of this operation.

Returns:

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

class `QuantizedSign`

Quantized Neg op.

property op_type

Get the type of this operation.

Returns:

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

constant_inputs

constant_inputs (Optional[Dict]): Input constant tensor.

concrete.ml.onnx.ops_impl

module `concrete.ml.onnx.ops_impl`

ONNX ops implementation in python + numpy.

function `cast_to_float`

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`

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`

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.

Returns:

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

function `numpy_where`

Compute the equivalent of numpy.where.

Args:

c (numpy.ndarray): Condition operand.
t (numpy.ndarray): True operand.

Returns:

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

function `numpy_add`

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`

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`

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`

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`

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`

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.

Returns:

Tuple[numpy.ndarray]: Output tensor

function `numpy_cos`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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

Returns:

Tuple[numpy.ndarray]: Output tensor

function `numpy_celu`

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`

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`

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`

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

Returns:

Tuple[numpy.ndarray]: Output tensor

function `numpy_softplus`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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)

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`

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`

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,)

Returns:

numpy.ndarray: Normalized tensor

function `numpy_flatten`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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)

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

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

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

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

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

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

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

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

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

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

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

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

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.

kernel_shape

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

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]

Contributing

There are three ways to contribute to Concrete-ML:

You can open issues to report bugs and typos and to suggest ideas.
You can ask to become an official contributor by emailing [email protected]. Only approved contributors can send pull requests (PR), so please make sure to get in touch before you do.
You can also provide new tutorials or use-cases, showing what can be done with the library. The more examples we have, the better and clearer it is for the other users.

1. Creating a new branch

Concrete-ML uses a consistent branch naming scheme, and you are expected to follow it as well. Here is the format, along with some examples:

e.g.

2. Before committing

2.1 Conformance

Each commit to Concrete-ML should conform to the standards of the project. You can let the development tools fix some issues automatically with the following command:

Conformance can be checked using the following command:

2.2 Testing

Your code must be well documented, containing tests and not breaking other tests:

You need to make sure you get 100% code coverage. The make pytest command checks that by default and will fail with a coverage report at the end should some lines of your code not be executed during testing.

If your coverage is below 100%, you should write more tests and then create the pull request. If you ignore this warning and create the PR, GitHub actions will fail and your PR will not be merged.

There may be cases where covering your code is not possible (an exception that cannot be triggered in normal execution circumstances). In those cases, you may be allowed to disable coverage for some specific lines. This should be the exception rather than the rule, and reviewers will ask why some lines are not covered. If it appears they can be covered, then the PR won't be accepted in that state.

3. Committing

Concrete-ML uses a consistent commit naming scheme, and you are expected to follow it as well (the CI will make sure you do). The accepted format can be printed to your terminal by running:

e.g.

To learn more about conventional commits, check page. Just a reminder that commit messages are checked in the comformance step and are rejected if they don't follow the rules.

4. Rebasing

You should rebase on top of the main branch before you create your pull request. Merge commits are not allowed, so rebasing on main before pushing gives you the best chance of avoiding having to rewrite parts of your PR later if conflicts arise with other PRs being merged. After you commit your changes to your new branch, you can use the following commands to rebase:

You can learn more about rebasing .

5. Releases

Before any final release, Concrete-ML contributors go through a release candidate (RC) cycle. The idea is that once the codebase and documentations look ready for a release, you create an RC release by opening an issue with the release template , starting with version vX.Y.Zrc1 and then with versions vX.Y.Zrc2, vX.Y.Zrc3...

Once the last RC is deemed ready, open an issue with the release template using the last RC version from which you remove the rc? part (i.e. v12.67.19 if your last RC version was v12.67.19-rc4) on .

git commit -m "feat: implement bounds checking"
git commit -m "feat(debugging): add an helper function to draw intermediate representation"
git commit -m "fix(tracing): fix a bug that crashed PyTorch tracer"

# fetch the list of active remote branches
git fetch --all --prune

# checkout to main
git checkout main

# pull the latest changes to main (--ff-only is there to prevent accidental commits to main)
git pull --ff-only

# checkout back to your branch
git checkout $YOUR_BRANCH

# rebase on top of main branch
git rebase main

# If there are conflicts during the rebase, resolve them
# and continue the rebase with the following command
git rebase --continue

# push the latest version of the local branch to remote
git push --force

0.5

What is Concrete ML?

hashtagExample usage

hashtagCurrent limitations

hashtagConcrete Stack

hashtagOnline demos and tutorials.

hashtagAdditional resources

hashtagLooking for support? Ask our team!

Getting Started

Installation

hashtagUsing PyPi

hashtagRequirements

hashtagInstallation

hashtagUsing Docker

Key Concepts

hashtagLifecycle of a Concrete-ML model

hashtag

Inference in the Cloud

Built-in Models

Pandas

hashtagExample

Built-in Model Examples

Deep Learning

Deep Learning Examples

hashtagSummary

hashtagExamples

Advanced topics

Pruning

hashtagOverview of pruning in Concrete-ML

Compilation

hashtagCompilation

Advanced Features

hashtagApproximate computations using the p_error parameter

Developer Guide

Workflow

Set Up Docker

hashtagBuilding the image

Documentation

hashtagUsing GitBook

Support and Issues

hashtagSubmitting an issue

Inner workings

Importing ONNX

hashtagTorch to NumPy conversion using ONNX

concrete.ml.common.debugging

hashtagmodule concrete.ml.common.debugging

hashtagGlobal Variables

concrete.ml.common.debugging.custom_assert

hashtagmodule concrete.ml.common.debugging.custom_assert

concrete.ml.common.utils

hashtagmodule concrete.ml.common.utils

concrete.ml.deployment

hashtagmodule concrete.ml.deployment

concrete.ml.onnx

hashtagmodule concrete.ml.onnx

hashtagGlobal Variables

concrete.ml.onnx.onnx_utils

hashtagmodule concrete.ml.onnx.onnx_utils

hashtagGlobal Variables

hashtagfunction get_attribute

hashtagfunction get_op_name

hashtagfunction execute_onnx_with_numpy

concrete.ml.quantization

hashtagmodule concrete.ml.quantization

concrete.ml.sklearn

hashtagmodule concrete.ml.sklearn

concrete.ml.sklearn.torch_module

hashtagmodule concrete.ml.sklearn.torch_module

concrete.ml.sklearn.tree_to_numpy

hashtagmodule concrete.ml.sklearn.tree_to_numpy

concrete.ml.torch

hashtagmodule concrete.ml.torch

hashtagGlobal Variables

concrete.ml.torch.numpy_module

hashtagmodule concrete.ml.torch.numpy_module

concrete.ml.version

hashtagmodule concrete.ml.version

Workflow

Inner workings

Installation

Example usage

Current limitations

Concrete Stack

Online demos and tutorials.

Additional resources

Looking for support? Ask our team!

Using PyPi

Requirements

Installation

Using Docker

Lifecycle of a Concrete-ML model

Example

Summary

Examples

Overview of pruning in Concrete-ML

Compilation

Approximate computations using the `p_error` parameter

Building the image

Using GitBook

Submitting an issue

Torch to NumPy conversion using ONNX

module `concrete.ml.common.debugging`

Global Variables

module `concrete.ml.common.debugging.custom_assert`

module `concrete.ml.common.utils`

module `concrete.ml.deployment`

module `concrete.ml.onnx`

Global Variables

module `concrete.ml.onnx.onnx_utils`

Global Variables

function `get_attribute`

function `get_op_name`

function `execute_onnx_with_numpy`

module `concrete.ml.quantization`

module `concrete.ml.sklearn`

module `concrete.ml.sklearn.torch_module`

module `concrete.ml.sklearn.tree_to_numpy`

module `concrete.ml.torch`

Global Variables

module `concrete.ml.torch.numpy_module`

module `concrete.ml.version`

Using PyPi

Requirements

Installation

Using Docker

Submitting an issue

module `concrete.ml.common.debugging`

Global Variables

module `concrete.ml.onnx`

Global Variables

Using GitBook

module `concrete.ml.sklearn`

module `concrete.ml.deployment`

module `concrete.ml.quantization`

module `concrete.ml.version`

Summary

Examples

module `concrete.ml.torch`

Global Variables

module `concrete.ml.common.debugging.custom_assert`

module `concrete.ml.common.utils`

Approximate computations using the `p_error` parameter

module `concrete.ml.sklearn.tree_to_numpy`

Building the image

module `concrete.ml.sklearn.torch_module`

function `assert_true`

function `assert_false`

function `assert_not_reached`

function `replace_invalid_arg_name_chars`

function `generate_proxy_function`

function `get_onnx_opset_version`

function `tree_to_numpy`

class `Task`

Example usage

Current limitations

Concrete Stack

Online demos and tutorials.

Additional resources

Looking for support? Ask our team!

Example