concrete.ml.quantization.quantized_module_passes.md
module concrete.ml.quantization.quantized_module_passes
concrete.ml.quantization.quantized_module_passes
Optimization passes for QuantizedModules.
class PowerOfTwoScalingRoundPBSAdapter
PowerOfTwoScalingRoundPBSAdapter
Detect neural network patterns that can be optimized with round PBS.
method __init__
__init__
__init__(qmodule: QuantizedModule) → None
property num_ignored_valid_patterns
Get the number of optimizable patterns that were ignored.
Patterns could be ignored since a number of rounding bits was set manually through the compilation function.
Returns:
result
(int): number of patterns that could be optimized but were not
method compute_op_predecessors
compute_op_predecessors
compute_op_predecessors() → DefaultDict[Union[QuantizedOp, NoneType], List[Tuple[Union[QuantizedOp, NoneType], str]]]
Compute the predecessors for each QuantizedOp in a QuantizedModule.
Stores, for each quantized op, a list of quantized ops that produce its inputs. Currently only the first input of the operations is considered as it is, usually, the encrypted input.
Returns:
result
(PredecessorsType): a dictionary containing a hierarchy of op predecessors
method detect_patterns
detect_patterns
detect_patterns(
predecessors: DefaultDict[Optional[QuantizedOp], List[Tuple[Optional[QuantizedOp], str]]]
) → Dict[QuantizedMixingOp, Tuple[List[Union[QuantizedOp, NoneType]], Union[QuantizedOp, NoneType]]]
Detect the patterns that can be optimized with roundPBS in the QuantizedModule.
Args:
predecessors
(PredecessorsType): Module predecessor operation list
Returns:
result
(PatternDict): list of optimizable patterns
method match_path_pattern
match_path_pattern
match_path_pattern(
predecessors: DefaultDict[Optional[QuantizedOp], List[Tuple[Optional[QuantizedOp], str]]],
nodes_in_path: List[Optional[QuantizedOp]],
input_producer_of_path: Optional[QuantizedOp]
) → bool
Determine if a pattern has the structure that makes it viable for roundPBS.
Args:
predecessors
(PredecessorsType): Module predecessor operation listnodes_in_path
(List[QuantizedOp]): list of quantized ops in the patterninput_producer_of_path
(Optional[QuantizedOp]): operation that produces the input
Returns:
result
(bool): whether the pattern can be optimized
method process
process
process() → Dict[QuantizedMixingOp, Tuple[List[Union[QuantizedOp, NoneType]], Union[QuantizedOp, NoneType]]]
Analyze an ONNX graph and detect Gemm/Conv patterns that can use RoundPBS.
We want to detect a gemm/conv node whose weights/bias are Brevitas QAT, and whose input is produced by a Brevitas QAT node that is applied on the output of another Gemm/conv node. Optionally a Relu can be placed before this input quantization node.
Nothing will be done if rounding is already specified.
Returns:
result
(PatternDict): a dictionary containing for each Conv/Gemm node for which round PBS can be applied based on power-of-two scaling factors
method process_patterns
process_patterns
process_patterns(
valid_paths: Dict[QuantizedMixingOp, Tuple[List[Optional[QuantizedOp]], Optional[QuantizedOp]]]
) → Dict[QuantizedMixingOp, Tuple[List[Union[QuantizedOp, NoneType]], Union[QuantizedOp, NoneType]]]
Configure the rounding bits of roundPBS for the optimizable operations.
Args:
valid_paths
(PatternDict): list of optimizable patterns
Returns:
result
(PatternDict): list of patterns actually optimized with roundPBS
Last updated
Was this helpful?