# 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.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.zama.org/concrete-ml/1.1/developer-guide/api/concrete.ml.torch.compile.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.