concrete.ml.common.utils.md

module `concrete.ml.common.utils`

Utils that can be re-used by other pieces of code in the module.

Global Variables

SUPPORTED_FLOAT_TYPES
SUPPORTED_INT_TYPES
SUPPORTED_TYPES
MAX_BITWIDTH_BACKWARD_COMPATIBLE
USE_OLD_VL
QUANT_ROUND_LIKE_ROUND_PBS

function `replace_invalid_arg_name_chars`

replace_invalid_arg_name_chars(arg_name: str) → str

Sanitize arg_name, replacing invalid chars by _.

This does not check that the starting character of arg_name is valid.

Args:

arg_name (str): the arg name to sanitize.

Returns:

str: the sanitized arg name, with only chars in _VALID_ARG_CHARS.

function `generate_proxy_function`

generate_proxy_function(
    function_to_proxy: Callable,
    desired_functions_arg_names: Iterable[str]
) → Tuple[Callable, Dict[str, str]]

Generate a proxy function for a function accepting only *args type arguments.

This returns a runtime compiled function with the sanitized argument names passed in desired_functions_arg_names as the arguments to the function.

Args:

function_to_proxy (Callable): the function defined like def f(*args) for which to return a function like f_proxy(arg_1, arg_2) for any number of arguments.
desired_functions_arg_names (Iterable[str]): the argument names to use, these names are sanitized and the mapping between the original argument name to the sanitized one is returned in a dictionary. Only the sanitized names will work for a call to the proxy function.

Returns:

Tuple[Callable, Dict[str, str]]: the proxy function and the mapping of the original arg name to the new and sanitized arg names.

function `get_onnx_opset_version`

get_onnx_opset_version(onnx_model: ModelProto) → int

Return the ONNX opset_version.

Args:

onnx_model (onnx.ModelProto): the model.

Returns:

int: the version of the model

function `manage_parameters_for_pbs_errors`

manage_parameters_for_pbs_errors(
    p_error: Optional[float] = None,
    global_p_error: Optional[float] = None
)

Return (p_error, global_p_error) that we want to give to Concrete.

The returned (p_error, global_p_error) depends on user's parameters and the way we want to manage defaults in Concrete ML, which may be different from the way defaults are managed in Concrete.

Principle: - if none are set, we set global_p_error to a default value of our choice - if both are set, we raise an error - if one is set, we use it and forward it to Concrete

Note that global_p_error is currently set to 0 in the FHE simulation mode.

Args:

p_error (Optional[float]): probability of error of a single PBS.
global_p_error (Optional[float]): probability of error of the full circuit.

Returns:

(p_error, global_p_error): parameters to give to the compiler

Raises:

ValueError: if the two parameters are set (this is not as in Concrete-Python)

function `check_there_is_no_p_error_options_in_configuration`

check_there_is_no_p_error_options_in_configuration(configuration)

Check the user did not set p_error or global_p_error in configuration.

It would be dangerous, since we set them in direct arguments in our calls to Concrete-Python.

Args:

configuration: Configuration object to use during compilation

function `get_model_class`

get_model_class(model_class)

Return the class of the model (instantiated or not), which can be a partial() instance.

Args:

model_class: The model, which can be a partial() instance.

Returns: The model's class.

function `is_model_class_in_a_list`

is_model_class_in_a_list(model_class, a_list)

Indicate if a model class, which can be a partial() instance, is an element of a_list.

Args:

model_class: The model, which can be a partial() instance.
a_list: The list in which to look into.

Returns: If the model's class is in the list or not.

function `get_model_name`

get_model_name(model_class)

Return the name of the model, which can be a partial() instance.

Args:

model_class: The model, which can be a partial() instance.

Returns: the model's name.

function `is_classifier_or_partial_classifier`

is_classifier_or_partial_classifier(model_class)

Indicate if the model class represents a classifier.

Args:

model_class: The model class, which can be a functool's partial class.

Returns:

bool: If the model class represents a classifier.

function `is_regressor_or_partial_regressor`

is_regressor_or_partial_regressor(model_class)

Indicate if the model class represents a regressor.

Args:

model_class: The model class, which can be a functool's partial class.

Returns:

bool: If the model class represents a regressor.

function `is_pandas_dataframe`

is_pandas_dataframe(input_container: Any) → bool

Indicate if the input container is a Pandas DataFrame.

This function is inspired from Scikit-Learn's test validation tools and avoids the need to add and import Pandas as an additional dependency to the project. See https://github.com/scikit-learn/scikit-learn/blob/98cf537f5/sklearn/utils/validation.py#L629

Args:

input_container (Any): The input container to consider

Returns:

bool: If the input container is a DataFrame

function `is_pandas_series`

is_pandas_series(input_container: Any) → bool

Indicate if the input container is a Pandas Series.

Args:

input_container (Any): The input container to consider

Returns:

bool: If the input container is a Series

function `is_pandas_type`

is_pandas_type(input_container: Any) → bool

Indicate if the input container is a Pandas DataFrame or Series.

Args:

input_container (Any): The input container to consider

Returns:

bool: If the input container is a DataFrame orSeries

function `check_dtype_and_cast`

check_dtype_and_cast(
    values: Any,
    expected_dtype: str,
    error_information: Optional[str] = ''
)

Convert any allowed type into an array and cast it if required.

If values types don't match with any supported type or the expected dtype, raise a ValueError.

Args:

values (Any): The values to consider
expected_dtype (str): The expected dtype, either "float32" or "int64"
error_information (str): Additional information to put in front of the error message when raising a ValueError. Default to None.

Returns:

(Union[numpy.ndarray, torch.utils.data.dataset.Subset]): The values with proper dtype.

Raises:

ValueError: If the values' dtype don't match the expected one or casting is not possible.

function `compute_bits_precision`

compute_bits_precision(x: ndarray) → int

Compute the number of bits required to represent x.

Args:

x (numpy.ndarray): Integer data

Returns:

int: the number of bits required to represent x

function `is_brevitas_model`

is_brevitas_model(model: Module) → bool

Check if a model is a Brevitas type.

Args:

model: PyTorch model.

Returns:

bool: True if model is a Brevitas network.

function `to_tuple`

to_tuple(x: Any) → tuple

Make the input a tuple if it is not already the case.

Args:

x (Any): The input to consider. It can already be an input.

Returns:

tuple: The input as a tuple.

function `all_values_are_integers`

all_values_are_integers(*values: Any) → bool

Indicate if all unpacked values are of a supported integer dtype.

Args:

*values (Any): The values to consider.

Returns:

bool: Whether all values are supported integers or not.

function `all_values_are_floats`

all_values_are_floats(*values: Any) → bool

Indicate if all unpacked values are of a supported float dtype.

Args:

*values (Any): The values to consider.

Returns:

bool: Whether all values are supported floating points or not.

function `all_values_are_of_dtype`

all_values_are_of_dtype(*values: Any, dtypes: Union[str, List[str]]) → bool

Indicate if all unpacked values are of the specified dtype(s).

Args:

*values (Any): The values to consider.
dtypes (Union[str, List[str]]): The dtype(s) to consider.

Returns:

bool: Whether all values are of the specified dtype(s) or not.

class `FheMode`

Enum representing the execution mode.

This enum inherits from str in order to be able to easily compare a string parameter to its equivalent Enum attribute.

Examples: fhe_disable = FheMode.DISABLE

fhe_disable == "disable" True

 >>> fhe_disable == "execute"
 False

 >>> FheMode.is_valid("simulate")
 True

 >>> FheMode.is_valid(FheMode.EXECUTE)
 True

 >>> FheMode.is_valid("predict_in_fhe")
 False

Previousconcrete.ml.common.serialization.md Nextconcrete.ml.deployment.deploy_to_aws.md

Last updated 2 years ago

Was this helpful?

hashtagmodule concrete.ml.common.utils

hashtagGlobal Variables

hashtagfunction replace_invalid_arg_name_chars

hashtagfunction generate_proxy_function

hashtagfunction get_onnx_opset_version

hashtagfunction manage_parameters_for_pbs_errors

hashtagfunction check_there_is_no_p_error_options_in_configuration

hashtagfunction get_model_class

hashtagfunction is_model_class_in_a_list

hashtagfunction get_model_name

hashtagfunction is_classifier_or_partial_classifier

hashtagfunction is_regressor_or_partial_regressor

hashtagfunction is_pandas_dataframe

hashtagfunction is_pandas_series

hashtagfunction is_pandas_type

hashtagfunction check_dtype_and_cast

hashtagfunction compute_bits_precision

hashtagfunction is_brevitas_model

hashtagfunction to_tuple

hashtagfunction all_values_are_integers

hashtagfunction all_values_are_floats

hashtagfunction all_values_are_of_dtype

hashtagclass FheMode

module `concrete.ml.common.utils`

Global Variables

function `replace_invalid_arg_name_chars`

function `generate_proxy_function`

function `get_onnx_opset_version`

function `manage_parameters_for_pbs_errors`

function `check_there_is_no_p_error_options_in_configuration`

function `get_model_class`

function `is_model_class_in_a_list`

function `get_model_name`

function `is_classifier_or_partial_classifier`

function `is_regressor_or_partial_regressor`

function `is_pandas_dataframe`

function `is_pandas_series`

function `is_pandas_type`

function `check_dtype_and_cast`

function `compute_bits_precision`

function `is_brevitas_model`

function `to_tuple`

function `all_values_are_integers`

function `all_values_are_floats`

function `all_values_are_of_dtype`

class `FheMode`