Configure

Concrete can be customized using Configurations:

from concrete import fhe
import numpy as np

configuration = fhe.Configuration(p_error=0.01, dataflow_parallelize=True)

@fhe.compiler({"x": "encrypted"})
def f(x):
    return x + 42

inputset = range(10)
circuit = f.compile(inputset, configuration=configuration)

You can overwrite individual options as kwargs to the compile method:

from concrete import fhe
import numpy as np

@fhe.compiler({"x": "encrypted"})
def f(x):
    return x + 42

inputset = range(10)
circuit = f.compile(inputset, p_error=0.01, dataflow_parallelize=True)

Or you can combine both:

from concrete import fhe
import numpy as np

configuration = fhe.Configuration(p_error=0.01)

@fhe.compiler({"x": "encrypted"})
def f(x):
    return x + 42

inputset = range(10)
circuit = f.compile(inputset, configuration=configuration, loop_parallelize=True)

Additional kwargs to compile functions take higher precedence. So if you set the option in both configuration and compile methods, the value in the compile method will be used.

Options

  • show_graph: Optional[bool] = None

    • Print computation graph during compilation. True means always print, False means never print, None means print depending on verbose configuration below.

  • show_mlir: Optional[bool] = None

    • Print MLIR during compilation. True means always print, False means never print, None means print depending on verbose configuration below.

  • show_optimizer: Optional[bool] = None

    • Print optimizer output during compilation. True means always print, False means never print, None means print depending on verbose configuration below.

  • show_statistics: Optional[bool] = None

    • Print circuit statistics during compilation. True means always print, False means never print, None means print depending on verbose configuration below.

  • verbose: bool = False

    • Print details related to compilation.

  • dump_artifacts_on_unexpected_failures: bool = True

    • Export debugging artifacts automatically on compilation failures.

  • auto_adjust_rounders: bool = False

    • Adjust rounders automatically.

  • p_error: Optional[float] = None

    • Error probability for individual table lookups. If set, all table lookups will have the probability of a non-exact result smaller than the set value. See Exactness to learn more.

  • global_p_error: Optional[float] = None

    • Global error probability for the whole circuit. If set, the whole circuit will have the probability of a non-exact result smaller than the set value. See Exactness to learn more.

  • single_precision: bool = False

    • Use single precision for the whole circuit.

  • parameter_selection_strategy: (fhe.ParameterSelectionStrategy) = fhe.ParameterSelectionStrategy.MULTI

    • Set how cryptographic parameters are selected.

  • multi_parameter_strategy: fhe.MultiParameterStrategy = fhe.MultiParameterStrategy.PRECISION

    • Set the level of circuit partionning when using fhe.ParameterSelectionStrategy.MULTI.

    • PRECISION: all TLU with same input precision have their own parameters.

    • PRECISION_AND_NORM2: all TLU with same input precision and output norm2 have their own parameters.

  • loop_parallelize: bool = True

    • Enable loop parallelization in the compiler.

  • dataflow_parallelize: bool = False

    • Enable dataflow parallelization in the compiler.

  • auto_parallelize: bool = False

    • Enable auto parallelization in the compiler.

  • use_gpu: bool = False

    • Enable generating code for GPU in the compiler.

  • enable_unsafe_features: bool = False

    • Enable unsafe features.

  • use_insecure_key_cache: bool = False (Unsafe)

    • Use the insecure key cache.

  • insecure_key_cache_location: Optional[Union[Path, str]] = None

    • Location of insecure key cache.

  • show_progress: bool = False,

    • Display a progress bar during circuit execution

  • progress_title: str = "",

    • Title of the progress bar

  • progress_tag: Union[bool, int] = False,

    • How many nested tag elements to display with the progress bar. True means all tag elements and False disables the display. 2 will display elmt1.elmt2

  • fhe_simulation: bool = False

    • Enable FHE simulation. Can be enabled later using circuit.enable_fhe_simulation().

  • fhe_execution: bool = True

    • Enable FHE execution. Can be enabled later using circuit.enable_fhe_execution().

  • compiler_debug_mode: bool = False,

    • Enable/disable debug mode of the compiler. This can show a lot of information, including passes and pattern rewrites.

  • compiler_verbose_mode: bool = False,

    • Enable/disable verbose mode of the compiler. This mainly shows logs from the compiler, and is less verbose than the debug mode.

  • comparison_strategy_preference: Optional[Union[ComparisonStrategy, str, List[Union[ComparisonStrategy, str]]]] = None

    • Specify preference for comparison strategies, can be a single strategy or an ordered list of strategies. See Comparisons to learn more.

  • bitwise_strategy_preference: Optional[Union[BitwiseStrategy, str, List[Union[BitwiseStrategy, str]]]] = None

    • Specify preference for bitwise strategies, can be a single strategy or an ordered list of strategies. See Bitwise to learn more.

  • shifts_with_promotion: bool = True,

    • Enable promotions in encrypted shifts instead of casting in runtime. See Bitwise#Shifts to learn more.

  • composable: bool = False,

    • Specify that the function must be composable with itself. Only used when compiling a single circuit; when compiling modules use the composition policy.

  • relu_on_bits_threshold: int = 7,

    • Bit-width to start implementing the ReLU extension with fhe.bits.

  • relu_on_bits_chunk_size: int = 3,

    • Chunk size of the ReLU extension when fhe.bits implementation is used.

  • if_then_else_chunk_size: int = 3

    • Chunk size to use when converting fhe.if_then_else extension.

  • rounding_exactness : Exactness = fhe.Exactness.EXACT

    • Set default exactness mode for the rounding operation:

    • EXACT: threshold for rounding up or down is exactly centered between upper and lower value,

    • APPROXIMATE: faster but threshold for rounding up or down is approximately centered with pseudo-random shift.

    • Precise and more complete behavior is described in fhe.rounding_bit_pattern.

  • approximate_rounding_config : ApproximateRoundingConfig = fhe.ApproximateRoundingConfig():

    • Provide more fine control on approximate rounding:

    • to enable exact cliping,

    • or/and approximate clipping which make overflow protection faster.

  • optimize_tlu_based_on_measured_bounds : bool = False

    • Enables TLU optimizations based on measured bounds.

    • Not enabled by default as it could result in unexpected overflows during runtime.

  • enable_tlu_fusing : bool = True

    • Enables TLU fusing to reduce the number of table lookups.

  • print_tlu_fusing : bool = False

    • Enables printing TLU fusing to see which table lookups are fused.

  • compress_evaluation_keys: bool = False,

    • This specifies that serialization takes the compressed form of evaluation keys.

  • compress_input_ciphertexts: bool = False,

    • This specifies that serialization takes the compressed form of input ciphertexts.

  • optimize_tlu_based_on_original_bit_width: Union[bool, int] = 8,

    • Configures whether to convert values to their original precision before doing a table lookup on them.

    • True enables it for all cases.

    • False disables it for all cases.

    • Integer value enables or disables it depending on the original bit width.

    • With the default value of 8, only the values with original bit width <= 8 will be converted to their original precision.

  • simulate_encrypt_run_decrypt: bool = False

    • Whether to use simulate encrypt/run/decrypt methods of the circuit/module instead of doing the actual encryption/evaluation/decryption.

      • When this option is set to True, encrypt and decrypt are identity functions, and run is a wrapper around simulation. In other words, this option allows to switch off the encryption to quickly test if a function has expected semantic (without paying the price of FHE execution).

    • This is extremely unsafe and should only be used during development.

    • For this reason, it requires enable_unsafe_features to be set to True.

Last updated