# concrete.ml.torch.compile.md

[![](https://img.shields.io/badge/-source-cccccc?style=flat-square)](https://github.com/zama-ai/concrete-ml/blob/release/1.1.x/src/concrete/ml/torch/compile.py#L0)

## module `concrete.ml.torch.compile`

torch compilation function.

### **Global Variables**

* **MAX\_BITWIDTH\_BACKWARD\_COMPATIBLE**
* **OPSET\_VERSION\_FOR\_ONNX\_EXPORT**

***

[![](https://img.shields.io/badge/-source-cccccc?style=flat-square)](https://github.com/zama-ai/concrete-ml/blob/release/1.1.x/src/concrete/ml/torch/compile.py#L34)

### function `convert_torch_tensor_or_numpy_array_to_numpy_array`

```python
convert_torch_tensor_or_numpy_array_to_numpy_array(
    torch_tensor_or_numpy_array: Union[Tensor, ndarray]
) → ndarray
```

Convert a torch tensor or a numpy array to a numpy array.

**Args:**

* `torch_tensor_or_numpy_array` (Tensor): the value that is either a torch tensor or a numpy array.

**Returns:**

* `numpy.ndarray`: the value converted to a numpy array.

***

[![](https://img.shields.io/badge/-source-cccccc?style=flat-square)](https://github.com/zama-ai/concrete-ml/blob/release/1.1.x/src/concrete/ml/torch/compile.py#L53)

### function `build_quantized_module`

```python
build_quantized_module(
    model: Union[Module, ModelProto],
    torch_inputset: Union[Tensor, ndarray, Tuple[Union[Tensor, ndarray], ]],
    import_qat: bool = False,
    n_bits=8,
    rounding_threshold_bits: Optional[int] = None
) → QuantizedModule
```

Build a quantized module from a Torch or ONNX model.

Take a model in torch or ONNX, turn it to numpy, quantize its inputs / weights / outputs and retrieve the associated quantized module.

**Args:**

* `model` (Union\[torch.nn.Module, onnx.ModelProto]): The model to quantize, either in torch or in ONNX.
* `torch_inputset` (Dataset): the calibration input-set, can contain either torch tensors or numpy.ndarray
* `import_qat` (bool): Flag to signal that the network being imported contains quantizers in in its computation graph and that Concrete ML should not re-quantize it
* `n_bits`: the number of bits for the quantization
* `rounding_threshold_bits` (int): if not None, every accumulators in the model are rounded down to the given bits of precision

**Returns:**

* `QuantizedModule`: The resulting QuantizedModule.

***

[![](https://img.shields.io/badge/-source-cccccc?style=flat-square)](https://github.com/zama-ai/concrete-ml/blob/release/1.1.x/src/concrete/ml/torch/compile.py#L187)

### function `compile_torch_model`

```python
compile_torch_model(
    torch_model: Module,
    torch_inputset: Union[Tensor, ndarray, Tuple[Union[Tensor, ndarray], ]],
    import_qat: bool = False,
    configuration: Optional[Configuration] = None,
    artifacts: Optional[DebugArtifacts] = None,
    show_mlir: bool = False,
    n_bits=8,
    rounding_threshold_bits: Optional[int] = None,
    p_error: Optional[float] = None,
    global_p_error: Optional[float] = None,
    verbose: bool = False
) → QuantizedModule
```

Compile a torch module into an FHE equivalent.

Take a model in torch, turn it to numpy, quantize its inputs / weights / outputs and finally compile it with Concrete

**Args:**

* `torch_model` (torch.nn.Module): the model to quantize
* `torch_inputset` (Dataset): the calibration input-set, can contain either torch tensors or numpy.ndarray.
* `import_qat` (bool): Set to True to import a network that contains quantizers and was trained using quantization aware training
* `configuration` (Configuration): Configuration object to use during compilation
* `artifacts` (DebugArtifacts): Artifacts object to fill during compilation
* `show_mlir` (bool): if set, the MLIR produced by the converter and which is going to be sent to the compiler backend is shown on the screen, e.g., for debugging or demo
* `n_bits`: the number of bits for the quantization
* `rounding_threshold_bits` (int): if not None, every accumulators in the model are rounded down to the given bits of precision
* `p_error` (Optional\[float]): probability of error of a single PBS
* `global_p_error` (Optional\[float]): probability of error of the full circuit. In FHE simulation `global_p_error` is set to 0
* `verbose` (bool): whether to show compilation information

**Returns:**

* `QuantizedModule`: The resulting compiled QuantizedModule.

***

[![](https://img.shields.io/badge/-source-cccccc?style=flat-square)](https://github.com/zama-ai/concrete-ml/blob/release/1.1.x/src/concrete/ml/torch/compile.py#L260)

### function `compile_onnx_model`

```python
compile_onnx_model(
    onnx_model: ModelProto,
    torch_inputset: Union[Tensor, ndarray, Tuple[Union[Tensor, ndarray], ]],
    import_qat: bool = False,
    configuration: Optional[Configuration] = None,
    artifacts: Optional[DebugArtifacts] = None,
    show_mlir: bool = False,
    n_bits=8,
    rounding_threshold_bits: Optional[int] = None,
    p_error: Optional[float] = None,
    global_p_error: Optional[float] = None,
    verbose: bool = False
) → QuantizedModule
```

Compile a torch module into an FHE equivalent.

Take a model in torch, turn it to numpy, quantize its inputs / weights / outputs and finally compile it with Concrete-Python

**Args:**

* `onnx_model` (onnx.ModelProto): the model to quantize
* `torch_inputset` (Dataset): the calibration input-set, can contain either torch tensors or numpy.ndarray.
* `import_qat` (bool): Flag to signal that the network being imported contains quantizers in in its computation graph and that Concrete ML should not re-quantize it.
* `configuration` (Configuration): Configuration object to use during compilation
* `artifacts` (DebugArtifacts): Artifacts object to fill during compilation
* `show_mlir` (bool): if set, the MLIR produced by the converter and which is going to be sent to the compiler backend is shown on the screen, e.g., for debugging or demo
* `n_bits`: the number of bits for the quantization
* `rounding_threshold_bits` (int): if not None, every accumulators in the model are rounded down to the given bits of precision
* `p_error` (Optional\[float]): probability of error of a single PBS
* `global_p_error` (Optional\[float]): probability of error of the full circuit. In FHE simulation `global_p_error` is set to 0
* `verbose` (bool): whether to show compilation information

**Returns:**

* `QuantizedModule`: The resulting compiled QuantizedModule.

***

[![](https://img.shields.io/badge/-source-cccccc?style=flat-square)](https://github.com/zama-ai/concrete-ml/blob/release/1.1.x/src/concrete/ml/torch/compile.py#L325)

### function `compile_brevitas_qat_model`

```python
compile_brevitas_qat_model(
    torch_model: Module,
    torch_inputset: Union[Tensor, ndarray, Tuple[Union[Tensor, ndarray], ]],
    n_bits: Optional[int, dict] = None,
    configuration: Optional[Configuration] = None,
    artifacts: Optional[DebugArtifacts] = None,
    show_mlir: bool = False,
    rounding_threshold_bits: Optional[int] = None,
    p_error: Optional[float] = None,
    global_p_error: Optional[float] = None,
    output_onnx_file: Union[Path, str] = None,
    verbose: bool = False
) → QuantizedModule
```

Compile a Brevitas Quantization Aware Training model.

The torch\_model parameter is a subclass of torch.nn.Module that uses quantized operations from brevitas.qnn. The model is trained before calling this function. This function compiles the trained model to FHE.

**Args:**

* `torch_model` (torch.nn.Module): the model to quantize
* `torch_inputset` (Dataset): the calibration input-set, can contain either torch tensors or numpy.ndarray.
* `n_bits` (Optional\[Union\[int, dict]): the number of bits for the quantization. By default, for most models, a value of None should be given, which instructs Concrete ML to use the bit-widths configured using Brevitas quantization options. For some networks, that perform a non-linear operation on an input on an output, if None is given, a default value of 8 bits is used for the input/output quantization. For such models the user can also specify a dictionary with model\_inputs/model\_outputs keys to override the 8-bit default or a single integer for both values.
* `configuration` (Configuration): Configuration object to use during compilation
* `artifacts` (DebugArtifacts): Artifacts object to fill during compilation
* `show_mlir` (bool): if set, the MLIR produced by the converter and which is going to be sent to the compiler backend is shown on the screen, e.g., for debugging or demo
* `rounding_threshold_bits` (int): if not None, every accumulators in the model are rounded down to the given bits of precision
* `p_error` (Optional\[float]): probability of error of a single PBS
* `global_p_error` (Optional\[float]): probability of error of the full circuit. In FHE simulation `global_p_error` is set to 0
* `output_onnx_file` (str): temporary file to store ONNX model. If None a temporary file is generated
* `verbose` (bool): whether to show compilation information

**Returns:**

* `QuantizedModule`: The resulting compiled QuantizedModule.