Concrete
WebsiteLibrariesProducts & ServicesDevelopersSupport
2.10
2.10
  • Welcome
  • Get Started
    • What is Concrete?
    • Installation
    • Quick start
    • Quick overview
    • Terminology
  • Operations
    • Table Lookups basics
    • Non-linear operations
    • Other operations
      • Bit extraction
      • Common tips
      • Extensions
  • Compilation
    • Combining compiled functions
      • With composition
      • With modules
    • Key-related options for faster execution
      • Multi precision
      • Multi parameters
    • Compression
    • Reusing arguments
    • Parameter compatibility with restrictions
    • Common errors
  • Execution / Analysis
    • Simulation
    • Debugging and artifact
    • Performance
    • GPU acceleration
    • Other
      • Statistics
      • Progressbar
      • Formatting and drawing
  • Guides
    • Configure
    • Manage keys
    • Deploy
    • TFHE-rs Interoperability
      • Shared key
      • Serialization
    • Optimization
      • Improve parallelism
        • Dataflow parallelism
        • Tensorizing operations
      • Optimize table lookups
        • Reducing TLU
        • Implementation strategies
        • Round/truncating
        • Approximate mode
        • Bit extraction
      • Optimize cryptographic parameters
        • Error probability
        • Composition
  • Tutorials
    • See all tutorials
    • Part I: Concrete - FHE compiler
    • Part II: The Architecture of Concrete
  • References
    • API
    • Supported operations
  • Explanations
    • Compiler workflow
    • Advanced features
      • Table Lookups advanced
      • Rounding
      • Truncating
      • Floating points
      • Comparisons
      • Min/Max operations
      • Bitwise operations
      • Direct circuits
      • Tagging
    • Cryptography basics
    • Security
    • Frontend fusing
  • Developers
    • Contributing
      • Project layout
      • Compiler backend
        • Adding a new backend
      • Optimizer
      • MLIR FHE dialects
        • FHELinalg dialect
        • FHE dialect
        • TFHE dialect
        • Concrete dialect
        • Tracing dialect
        • Runtime dialect
        • SDFG dialect
      • Call FHE circuits from other languages
      • Benchmarking
      • Examples
      • Making a release
    • Release note
    • Feature request
    • Bug report
Powered by GitBook

Libraries

  • TFHE-rs
  • Concrete
  • Concrete ML
  • fhEVM

Developers

  • Blog
  • Documentation
  • Github
  • FHE resources

Company

  • About
  • Introduction to FHE
  • Media
  • Careers
On this page

Was this helpful?

Export as PDF
  1. Guides

Configure

This document provides instructions on how to customize the compilation pipeline using Configurations in Python and describes various configuration options available.

You can customize Concrete using the fhe.Configuration :

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 configuration options by specifying kwargs in 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)

You can also combine both ways:

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)

When options are specified both in the configuration and as kwargs in the compile method, the kwargs take precedence.

Options

approximate_rounding_config: ApproximateRoundingConfig = fhe.ApproximateRoundingConfig()

    • To enable exact clipping,

    • Or/and approximate clipping, which makes overflow protection faster.

auto_adjust_rounders: bool = False

  • Adjust rounders automatically.

auto_parallelize: bool = False

  • Enable auto parallelization in the compiler.

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

compiler_debug_mode: bool = False

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

compiler_verbose_mode: bool = False

  • Enable or 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

compress_evaluation_keys: bool = False

  • Specify that serialization takes the compressed form of evaluation keys.

compress_input_ciphertexts: bool = False

  • Specify that serialization takes the compressed form of input ciphertexts.

composable: bool = False

  • Specify that the function must be composable with itself.

dataflow_parallelize: bool = False

  • Enable dataflow parallelization in the compiler.

dump_artifacts_on_unexpected_failures: bool = True

  • Export debugging artifacts automatically on compilation failures.

enable_tlu_fusing: bool = True

  • Enables Table Lookups(TLU) fusing to reduce the number of TLUs.

enable_unsafe_features: bool = False

  • Enable unsafe features.

fhe_execution: bool = True

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

fhe_simulation: bool = False

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

global_p_error: Optional[float] = None

  • Global error probability for the whole circuit.

if_then_else_chunk_size: int = 3

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

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

  • Location of insecure key cache.

loop_parallelize: bool = True

  • Enable loop parallelization in the compiler.

multi_parameter_strategy: fhe.MultiParameterStrategy = fhe.MultiParameterStrategy.PRECISION

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

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

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.

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.

p_error: Optional[float] = None

  • Error probability for individual table lookups.

parameter_selection_strategy: fhe.ParameterSelectionStrategy = fhe.ParameterSelectionStrategy.MULTI

  • Set how cryptographic parameters are selected.

print_tlu_fusing: bool = False

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

progress_tag: Union[bool, int] = False

  • How many nested tag elements to display with the progress bar.

    • True means all tag elements

    • False disables the display.

    • 2 will display elmt1.elmt2.

progress_title: str = ""

  • Title of the progress bar.

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 the upper and lower value.

relu_on_bits_chunk_size: int = 3

relu_on_bits_threshold: int = 7

shifts_with_promotion: bool = True

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.

show_mlir: Optional[bool] = None

  • Print MLIR during compilation.

    • True means always print

    • False means never print

    • None means print depending on verbose configuration.

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.

show_progress: bool = False

  • Display a progress bar during circuit execution.

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.

simulate_encrypt_run_decrypt: bool = False

  • Whether to use the simulate encrypt/run/decrypt methods of the circuit/module instead of 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 switching off encryption to quickly test if a function has the 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.

single_precision: bool = False

  • Use single precision for the whole circuit.

range_restriction: Optional[RangeRestriction] = None

  • A range restriction to pass to the optimizer to restrict the available crypto-parameters.

keyset_restriction: Optional[KeysetRestriction] = None

  • A keyset restriction to pass to the optimizer to restrict the available crypto-parameters.

use_gpu: bool = False

  • Enable generating code for GPU in the compiler.

use_insecure_key_cache: bool = False (Unsafe)

  • Use the insecure key cache.

verbose: bool = False

  • Print details related to compilation.

auto_schedule_run: bool = False

  • Enable automatic scheduling of run method calls. When enabled, fhe function are computated in parallel in a background threads pool. When several run are composed, they are automatically synchronized.

  • For now, it only works for the run method of a FheModule, in that case you obtain a Future[Value] immediately instead of a Value when computation is finished.

  • E.g. my_module.f3.run( my_module.f1.run(a), my_module.f1.run(b) ) will runs f1 and f2 in parallel in the background and f3 in background when both f1 and f2 intermediate results are available.

  • If you want to manually synchronize on the termination of a full computation, e.g. you want to return the encrypted result, you can call explicitely value.result() to wait for the result. To simplify testing, decryption does it automatically.

  • Automatic scheduling behavior can be override locally by calling directly a variant of run:

    • run_sync: forces the fhe function to occur in the current thread, not in the background,

    • run_async: forces the fhe function to occur in a background thread, returning immediately a Future[Value]

security_level: int = 128

  • Set the level of security used to perform the optimization of crypto-parameters.

PreviousFormatting and drawingNextManage keys

Last updated 1 month ago

Was this helpful?

Provide fine control for :

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

Specify preference for comparison strategies. Can be a single strategy or an ordered list of strategies. See to learn more.

Only used when compiling a single circuit; when compiling modules, use the .

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

PRECISION_AND_NORM2: all TLUs with the same input precision and output have their own parameters.

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

APPROXIMATE: faster but threshold for rounding up or down is approximately centered with a pseudo-random shift. Precise behavior is described in .

Chunk size of the ReLU extension when implementation is used.

Bit-width to start implementing the ReLU extension with .

Enable promotions in encrypted shifts instead of casting at runtime. See to learn more.

Bitwise
Comparisons
norm2
fhe.rounding_bit_pattern
fhe.bits
fhe.bits
Exactness
Exactness
composition policy
Bitwise#Shifts
approximate rounding