hls4ml.model package
Subpackages
- hls4ml.model.flow package
- hls4ml.model.optimizer package
- Subpackages
- hls4ml.model.optimizer.passes package
- Submodules
- hls4ml.model.optimizer.passes.bn_fuse module
- hls4ml.model.optimizer.passes.convert_to_channels_last module
- hls4ml.model.optimizer.passes.expand_layer_group module
- hls4ml.model.optimizer.passes.fuse_biasadd module
- hls4ml.model.optimizer.passes.multi_dense module
- hls4ml.model.optimizer.passes.nop module
- hls4ml.model.optimizer.passes.precision_merge module
- hls4ml.model.optimizer.passes.qkeras module
- hls4ml.model.optimizer.passes.stamp module
- hls4ml.model.optimizer.passes.transpose_opt module
- Module contents
- hls4ml.model.optimizer.passes package
- Submodules
- hls4ml.model.optimizer.optimizer module
- Module contents
- Subpackages
Submodules
hls4ml.model.attributes module
All information about a layer is stored in the attributes of a layer instance. This information can be properties of a layer, like a number of hidden units in Dense layer or number of filters in a convolutional layer, but also includes information about weight variables, output variables and all data types defined. The attribute system provides a mechanism that ensures layers are correctly initialized, have the valid information stored and have configurable endpoints exposed.
This module contains the definitions of classes for handling attributes. The Attribute
class and its subclasses provide
information about an expected attribute, but the actual value will be stored within the instance’s attribute
dict. This
provides an unified view (mapping) of all attributes, but for convenience there are mappings that expose only certain types
of attributes, such as types, variables, weights etc, via the AttributeMapping
class.
- class hls4ml.model.attributes.Attribute(name, value_type=<class 'numbers.Integral'>, default=None, configurable=False)
Bases:
object
Base attribute class.
Attribute consists of a name, the type of value it will store, the optional default if no value is specified during layer creation, and a flag indicating if the value can be modified by the user. This class is generally expected to exist only as part of the
expected_attributes
property of the layer class.- Parameters:
name (str) – Name of the attribute
value_type (optional) – Type of the value expected to be stored in the attribute. If not specified, no validation of the stored value will be performed. Defaults to
int
.default (optional) – Default value if no value is specified during layer creation. Defaults to
None
.configurable (bool, optional) – Specifies if the attribute can be modified after creation. Defaults to
False
.
- property config_name
Returns the name of the attribute as it will appear in the
attribute
dict of the layer instance.The format will be in pascal case, e.g.,
AttributeName
->attribute_name
.- Returns:
The pascal_case of the name of the attribute.
- Return type:
str
- validate_value(value)
- class hls4ml.model.attributes.AttributeDict(layer)
Bases:
MutableMapping
Class containing all attributes of a given layer.
Instances of this class behave like a dictionary. Upon insertion, the key/value may trigger additional actions, such as registering variables or modifying the key name to ensure it follows the convention.
Specific “views” (mappings) of this class can be used to filter desired attributes via the
AttributeMapping
class.
- class hls4ml.model.attributes.AttributeMapping(attributes, clazz)
Bases:
MutableMapping
Base class used to filter attributes based on their expected class.
- class hls4ml.model.attributes.ChoiceAttribute(name, choices, default=None, configurable=True)
Bases:
Attribute
Represents an attribute whose value can be one of several predefined values.
- validate_value(value)
- class hls4ml.model.attributes.CodeAttrubute(name)
Bases:
Attribute
Represents an attribute that will store generated source code block.
- class hls4ml.model.attributes.CodeMapping(attributes)
Bases:
AttributeMapping
Mapping that only sees
Source
instances (i.e., generated source code blocks).
- class hls4ml.model.attributes.ConfigurableAttribute(name, value_type=<class 'int'>, default=None)
Bases:
Attribute
Represents a configurable attribute, i.e., the attribute whose value can be modified by the user.
This is a convenience class. It is advised to use
ConfigurableAttribute
overAttribute(..., configurable=True)
when defining the expected attributes of layer classes.
- class hls4ml.model.attributes.TypeAttribute(name, default=None, configurable=True)
Bases:
Attribute
Represents an attribute that will store a type, i.e., an instance of
NamedType
or its subclasses.As a convention, the name of the attribute storing a type will end in
_t
.
- class hls4ml.model.attributes.TypeMapping(attributes)
Bases:
AttributeMapping
Mapping that only sees
NamedType
instances (i.e., defined types).
- class hls4ml.model.attributes.VariableMapping(attributes)
Bases:
AttributeMapping
Mapping that only sees
TensorVariable
instances (i.e., activation tensors).
- class hls4ml.model.attributes.WeightAttribute(name)
Bases:
Attribute
Represents an attribute that will store a weight variable.
- class hls4ml.model.attributes.WeightMapping(attributes)
Bases:
AttributeMapping
Mapping that only sees
WeightVariable
instances (i.e., weights).
hls4ml.model.graph module
- class hls4ml.model.graph.HLSConfig(config)
Bases:
object
The configuration class as stored in the ModelGraph.
- Parameters:
config (dict) – The configuration dictionary
- get_bram_size(layer)
- get_compression(layer)
- get_config_value(key, default=None)
- get_conv_implementation(layer)
- get_layer_config(layer)
- get_layer_config_value(layer, key, default=None)
- get_output_dir()
- get_precision(layer, var='default')
- get_project_name()
- get_reuse_factor(layer)
- get_strategy(layer)
- get_target_cycles(layer)
- is_resource_strategy(layer)
- class hls4ml.model.graph.ModelGraph(config, layer_list, inputs=None, outputs=None)
Bases:
object
The ModelGraph represents the network that is being processed by hls4ml.
- Parameters:
config (dict) – The configuration dictionary
layer_list (list(dict)) – The list contains a dictionary for each input layer
inputs (list, optional) – The inputs to the model. If None, determined from layer_list
outputs (list, optional) – The outputs to the model. If None, determined from layer_list
- apply_flow(flow, reapply='single')
Applies a flow (a collection of optimizers).
- Parameters:
flow (str) – The name of the flow to apply
reapply (str, optional) – Determines the action to take if the flow and its requirements have already been applied. Possible values are: - ‘all’: Apply the flow and all its requirements. - ‘single’: Apply only the given flow, but skip the already applied requirements. - ‘none’: Skip applying the flow. Defaults to ‘single’.
- build(**kwargs)
Builds the generated project using HLS compiler.
Please see the build() function of backends for a list of possible arguments.
- compile()
Compile the generated project and link the library into current environment.
Users should call this function if they want to use predict functionality for simulation.
- get_input_variables()
- get_layer_output_variable(output_name)
- get_layers()
- get_output_variables()
- get_weight_variables()
- insert_node(node, before=None, input_idx=0)
Insert a new node into the model graph.
The node to be inserted should be created with make_node() function. The optional parameter before can be used to specify the node that follows in case of ambiguities.
- Parameters:
- Raises:
Exception – If an attempt to insert a node with multiple inputs is made or if before does not specify a correct node in sequence.
- make_node(kind, name, attributes, inputs, outputs=None)
Make a new node not connected to the model graph.
The ‘kind’ should be a valid layer registered with register_layer. If no outputs are specified, a default output named the same as the node will be created. The returned node should be added to the graph with insert_node or replace_node functions.
- Parameters:
kind (type or str) – Type of node to add
name (str) – Name of the node
attributes (dict) – Initial set of attributes required to construct the node (Layer)
inputs (list) – List of inputs to the layer
outputs (list, optional) – The optional list of named outputs of the node
- Raises:
Exception – If an attempt to insert a node with multiple inputs is made or if before does not specify a correct node in sequence.
- Returns:
The node created.
- Return type:
- next_layer()
- predict(x)
- register_output_variable(out_name, variable)
- remove_node(node, rewire=True)
Remove a node from a graph.
By default, this function can connect the outputs of previous node to the input of next one. Note that when removing a leaf node rewire should be set to False.
- Parameters:
node (Layer) – The node to remove
rewire (bool, optional) – If True, connects the outputs of the previous node to the inputs of the next node
- Raises:
Exception – If an attempt is made to rewire a leaf node or a node with multiple inputs/outputs.
- replace_node(old_node, new_node)
Replace an existing node in the graph with a new one.
- trace(x)
- write()
Write the generated project to disk.
This function converts the model to C++ and writes the generated files in the output directory specified in the config.
hls4ml.model.layers module
- class hls4ml.model.layers.Activation(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.BatchNormalization(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.BiasAdd(model, name, attributes, inputs, outputs=None)
Bases:
Merge
- initialize()
- class hls4ml.model.layers.Concatenate(model, name, attributes, inputs, outputs=None)
Bases:
Merge
- initialize()
- class hls4ml.model.layers.Conv1D(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.Conv2D(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.Conv2DBatchnorm(model, name, attributes, inputs, outputs=None)
Bases:
Conv2D
- initialize()
- class hls4ml.model.layers.Dense(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.DepthwiseConv1D(model, name, attributes, inputs, outputs=None)
Bases:
Conv1D
- initialize()
- class hls4ml.model.layers.DepthwiseConv2D(model, name, attributes, inputs, outputs=None)
Bases:
Conv2D
- initialize()
- class hls4ml.model.layers.Dot(model, name, attributes, inputs, outputs=None)
Bases:
Merge
- initialize()
- class hls4ml.model.layers.Embedding(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.GRU(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.GarNet(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- ref_impl = False
- class hls4ml.model.layers.GlobalPooling1D(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.GlobalPooling2D(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.HardActivation(model, name, attributes, inputs, outputs=None)
Bases:
Activation
Implements the hard sigmoid and tan function in keras and qkeras (Default parameters in qkeras are different, so should be configured) The hard sigmoid unction is clip(slope * x + shift, 0, 1), and the hard tanh function is 2 * hard_sigmoid - 1
- initialize()
- class hls4ml.model.layers.Input(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.LSTM(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.Layer(model, name, attributes, inputs, outputs=None)
Bases:
object
The base class for all layers, which are the nodes in the model graph. Note: they don’t necessarily correspond 1:1 with the network layers.
The expected attributes are index, trace (configurable), and result (type)
- Parameters:
model (ModelGraph) – The ModelGraph that this Layer is part of
name (str) – The node name
attributes (dict) – Initial set of attributes required to construct the node (Layer)
inputs (list) – List of inputs to the layer
outputs (list, optional) – The optional list of named outputs of the node
- add_bias(quantizer=None)
- add_output_variable(shape, dim_names, out_name=None, var_name='layer{index}_out', type_name='layer{index}_t', precision=None)
- add_weights(quantizer=None, compression=False)
- add_weights_variable(name, var_name=None, type_name=None, precision=None, data=None, quantizer=None, compression=False)
- property class_name
- expected_attributes = [<hls4ml.model.attributes.Attribute object>, <hls4ml.model.attributes.ConfigurableAttribute object>, <hls4ml.model.attributes.TypeAttribute object>]
- get_attr(key, default=None)
- get_input_node(input_name=None)
- get_input_variable(input_name=None)
- get_layer_precision()
- get_output_nodes(output_name=None)
- get_output_use_map()
- get_output_variable(output_name=None)
- get_variables()
- get_weights(var_name=None)
- initialize()
- set_attr(key, value)
- class hls4ml.model.layers.LayerGroup(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.Merge(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.PReLU(model, name, attributes, inputs, outputs=None)
Bases:
Activation
- initialize()
- class hls4ml.model.layers.ParametrizedActivation(model, name, attributes, inputs, outputs=None)
Bases:
Activation
- class hls4ml.model.layers.Pooling1D(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.Pooling2D(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.Reshape(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.Resize(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.SeparableConv1D(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.SeparableConv2D(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.SimpleRNN(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.Softmax(model, name, attributes, inputs, outputs=None)
Bases:
Activation
- initialize()
- class hls4ml.model.layers.SymbolicExpression(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.TernaryTanh(model, name, attributes, inputs, outputs=None)
Bases:
Activation
- initialize()
- class hls4ml.model.layers.Transpose(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.ZeroPadding1D(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.ZeroPadding2D(model, name, attributes, inputs, outputs=None)
Bases:
Layer
- initialize()
- class hls4ml.model.layers.classproperty(func)
Bases:
object
- hls4ml.model.layers.register_layer(name, clazz)
hls4ml.model.profiling module
- hls4ml.model.profiling.activation_types_hlsmodel(model)
- hls4ml.model.profiling.activations_hlsmodel(model, X, fmt='summary', plot='boxplot')
- hls4ml.model.profiling.activations_keras(model, X, fmt='longform', plot='boxplot')
- hls4ml.model.profiling.activations_torch(model, X, fmt='longform', plot='boxplot')
- hls4ml.model.profiling.ap_fixed_WIFS(dtype)
- hls4ml.model.profiling.array_to_summary(x, fmt='boxplot')
- hls4ml.model.profiling.boxplot(data, fmt='longform')
- hls4ml.model.profiling.compare(keras_model, hls_model, X, plot_type='dist_diff')
Compare each layer’s output in keras and hls model. Note that the hls_model should not be compiled before using this.
- Parameters:
keras_model – Original keras model.
hls_model (ModelGraph) – Converted ModelGraph, with “Trace:True” in the configuration file.
X (ndarray) – Input tensor for the model.
plot_type (str, optional) – Different methods to visualize the y_model and y_sim differences. Possible options include: - ‘norm_diff’:: square root of the sum of the squares of the differences between each output vectors. - ‘dist_diff’:: The normalized distribution of the differences of the elements between two output vectors. Defaults to “dist_diff”.
- Returns:
Plot object of the histogram depicting the difference in each layer’s output.
- Return type:
matplotlib figure
- hls4ml.model.profiling.get_unoptimized_hlsmodel(model)
- hls4ml.model.profiling.get_ymodel_keras(keras_model, X)
Calculate each layer’s ouput and put them into a dictionary.
- Parameters:
keras_model (_type_) – A keras Model
X (ndarray) – Test data on which to evaluate the model to profile activations. Must be formatted suitably for the
model.predict(X)
.
- Returns:
A dictionary in the form {“layer_name”: ouput array of layer}.
- Return type:
dict
- hls4ml.model.profiling.histogram(data, fmt='longform')
- hls4ml.model.profiling.numerical(model=None, hls_model=None, X=None, plot='boxplot')
Perform numerical profiling of a model.
- Parameters:
model (optional) – Keras of PyTorch model. Defaults to None.
hls_model (ModelGraph, optional) – The ModelGraph to profile. Defaults to None.
X (ndarray, optional) – Test data on which to evaluate the model to profile activations. Must be formatted suitably for the
model.predict(X)
. Defaults to None.plot (str, optional) – The type of plot to produce. Options are: ‘boxplot’ (default), ‘violinplot’, ‘histogram’, ‘FacetGrid’. Defaults to ‘boxplot’.
- Returns:
- The quadruple of produced figures. First weights and biases
for the pre- and post-optimization models respectively, then activations for the pre- and post-optimization models respectively. (Optimizations are applied to an ModelGraph by hls4ml, a post-optimization ModelGraph is a final model).
- Return type:
tuple
- hls4ml.model.profiling.types_boxplot(data, fmt='longform')
- hls4ml.model.profiling.types_histogram(data, fmt='longform')
- hls4ml.model.profiling.types_hlsmodel(model)
- hls4ml.model.profiling.weights_hlsmodel(model, fmt='longform', plot='boxplot')
- hls4ml.model.profiling.weights_keras(model, fmt='longform', plot='boxplot')
- hls4ml.model.profiling.weights_torch(model, fmt='longform', plot='boxplot')
hls4ml.model.types module
This module contains the definitions of classes hls4ml uses to represent data types. The data types are equivalents of
C++/HLS data types. The basic type(PrecisionType
) is defined as having a specified width in bits (it’s ‘precision’).
The Precision types are given names for convenience (NamedType
). Named types are the building blocks of
higher-dimensional tensors, which are defined as arrays or FIFO streams in the generated code.
- class hls4ml.model.types.BinaryQuantizer(bits=2)
Bases:
Quantizer
Quantizer that quantizes to 0 and 1 (
bits=1
) or -1 and 1 (bits==2
).- Parameters:
bits (int, optional) – Number of bits used by the quantizer. Defaults to 2.
- Raises:
Exception – Raised if
bits>2
- class hls4ml.model.types.CompressedType(name, precision, index_precision, **kwargs)
Bases:
NamedType
Class representing a compressed type in COO format.
- Parameters:
name (str) – Name given to the type (used in generated C++/HLS).
precision (PrecisionType) – Precision data type.
index_precision (PrecisionType) – Precision of the index of COO format.
- class hls4ml.model.types.CompressedWeightVariable(var_name, type_name, precision, data, reuse_factor, quantizer=None, **kwargs)
Bases:
WeightVariable
Class representing a tensor containing the weights of a layer represented in the COO format.
- Parameters:
var_name (str, optional) – Name of the variable in the generated C++/HLS.
type_name (str, optional) – Name of the data type used (in NamedType).
precision (PrecisionType, optional) – Precision data type.
data (ndarray) – The data array.
reuse_factor (_type_) – The reuse factor used to pad the data array.
quantizer (_type_, optional) – Quantizer to apply to the data array. Defaults to
None
.
- next()
- class hls4ml.model.types.ExponentPrecisionType(width=16, signed=True)
Bases:
PrecisionType
Convenience class to differentiate ‘regular’ integers from those which represent exponents, for QKeras po2 quantizers, for example.
- class hls4ml.model.types.ExponentType(name, precision, **kwargs)
Bases:
NamedType
Special type used to mark an exponent type, used by the power-of-2 quantizers.
- Parameters:
name (str) – Name given to the type (used in generated C++/HLS).
precision (PrecisionType) – Precision data type.
- class hls4ml.model.types.ExponentWeightVariable(var_name, type_name, precision, data, quantizer=None, **kwargs)
Bases:
WeightVariable
WeightVariable for Exponent aka power-of-2 data. The data should already by quantized by the quantizer.
- Parameters:
var_name (str, optional) – Name of the variable in the generated C++/HLS.
type_name (str, optional) – Name of the data type used (in NamedType).
precision (PrecisionType, optional) – Precision data type.
data (ndarray) – The data array.
quantizer (_type_, optional) – Quantizer to apply to the data array. Defaults to
None
.
- next()
- class hls4ml.model.types.FixedPrecisionType(width=16, integer=6, signed=True, rounding_mode=None, saturation_mode=None, saturation_bits=None)
Bases:
PrecisionType
Arbitrary precision fixed-point data type.
This type is equivalent to ap_(u)fixed and ac_fixed HLS types.
- Parameters:
width (int, optional) – Total number of bits used. Defaults to 16.
integer (int, optional) – Number of integer bits left of the decimal point. Defaults to 6.
signed (bool, optional) – Signed or unsigned type. Defaults to
True
.rounding_mode (RoundingMode, optional) – Quantization mode. Defaults to
None
(TRN).saturation_mode (SaturationMode, optional) – Overflow mode. Defaults to
None
(WRAP).saturation_bits (int, optional) – The number of saturation bits. Defaults to
None
.
- property rounding_mode
- property saturation_mode
- class hls4ml.model.types.InplaceTensorVariable(tv, input_var)
Bases:
TensorVariable
A
TensorVariable
that is just a link to anotherTensorVariable
.- Parameters:
tv (TensorVariable) – The tensor variable to link.
input_var (_type_) – The input variable that should be should link to.
- class hls4ml.model.types.IntegerPrecisionType(width=16, signed=True)
Bases:
PrecisionType
Arbitrary precision integer data type.
This type is equivalent to ap_(u)int and ac_int HLS types.
- Parameters:
width (int, optional) – Number of bits used. Defaults to 16.
signed (bool, optional) – Signed or unsigned type. Defaults to
True
.
- class hls4ml.model.types.NamedType(name, precision, **kwargs)
Bases:
object
Class representing a named type.
For convenience, hls4ml gives names to data types used in the generated HLS. This is equivalent to defining types in C/C++ like:
typedef precision name;
- Parameters:
name (str) – Name given to the type (used in generated C++/HLS).
precision (PrecisionType) – Precision data type.
- class hls4ml.model.types.PackedType(name, precision, n_elem, n_pack, **kwargs)
Bases:
NamedType
A type where multiple elements of the tensor are concatenated and stored as a single element, used by the streaming implementations to store elements of the last dimension of a tensor as a single element.
The tensor of shape
(H, W, C)
will be represented as a FIFO stream havingH * W / n_pack
elements where each element will be a concatenation ofn_elem * n_pack
elements of the original tensor.- Parameters:
name (str) – Name given to the type (used in generated C++/HLS).
precision (PrecisionType) – Precision data type.
n_elem (int) – Number of packed elements.
n_pack (int) – _description_
- class hls4ml.model.types.PrecisionType(width, signed)
Bases:
object
Base class representing a precision type of specified width.
Subclasses of this provide concrete implementations of arbitrary precision integer and fixed-point types.
- Parameters:
width (int) – Number of bits used by the precision type.
signed (bool) – Signed or unsigned type.
- class hls4ml.model.types.QKerasBinaryQuantizer(config, xnor=False)
Bases:
Quantizer
Wrapper around QKeras binary quantizer.
- Parameters:
config (dict) – Config of the QKeras quantizer to wrap.
- class hls4ml.model.types.QKerasPO2Quantizer(config)
Bases:
Quantizer
Wrapper around QKeras power-of-2 quantizers.
- Parameters:
config (dict) – Config of the QKeras quantizer to wrap.
- class hls4ml.model.types.QKerasQuantizer(config)
Bases:
Quantizer
Wrapper around QKeras quantizers.
- Parameters:
config (dict) – Config of the QKeras quantizer to wrap.
- class hls4ml.model.types.Quantizer(bits, hls_type)
Bases:
object
Base class for representing quantizers in hls4ml.
Subclasses of
Quantizer
are expected to wrap the quantizers of upstream tools (e.g., QKeras).- Parameters:
bits (int) – Total number of bits used by the quantizer.
hls_type (NamedType) – The hls4ml type used by the quantizer.
- class hls4ml.model.types.RoundingMode(value)
Bases:
Enum
An enumeration.
- RND = 3
- RND_CONV = 7
- RND_INF = 5
- RND_MIN_INF = 6
- RND_ZERO = 4
- TRN = 1
- TRN_ZERO = 2
- classmethod from_string(mode)
- class hls4ml.model.types.SaturationMode(value)
Bases:
Enum
An enumeration.
- SAT = 2
- SAT_SYM = 4
- SAT_ZERO = 3
- WRAP = 1
- classmethod from_string(mode)
- class hls4ml.model.types.Source(code)
Bases:
object
Class representing generated source code blocks.
- Parameters:
code (str) – Generated source code.
- class hls4ml.model.types.TensorVariable(shape, dim_names, var_name='layer{index}', type_name='layer{index}_t', precision=None, **kwargs)
Bases:
Variable
Class representing the output of a layer (like an activation tensor).
- Parameters:
shape (list, tuple) – Shape of the tensor.
dim_names (list, tuple) – Names given to the dimensions of the tensor.
var_name (str, optional) – Name of the variable in the generated C++/HLS. Defaults to
layer{index}
.type_name (str, optional) – Name of the data type used (in NamedType). Defaults to
layer{index}_t
.precision (PrecisionType, optional) – Precision data type. Defaults to
None
.
- get_shape()
- size()
- size_cpp()
- class hls4ml.model.types.TernaryQuantizer
Bases:
Quantizer
Quantizer that quantizes to -1, 0 and 1.
- class hls4ml.model.types.Variable(var_name, atype, **kwargs)
Bases:
object
Base class representing a named multidimensional tensor.
- Parameters:
var_name (str) – Name of the variable in the generated C++/HLS.
atype (NamedType) – Data type used by the tensor.
- class hls4ml.model.types.WeightVariable(var_name, type_name, precision, data, quantizer=None, **kwargs)
Bases:
Variable
Class representing a tensor containing the weights of a layer.
Precision type of the instance can be modified with the
update_precision
method.- Parameters:
var_name (str, optional) – Name of the variable in the generated C++/HLS.
type_name (str, optional) – Name of the data type used (in NamedType).
precision (PrecisionType, optional) – Precision data type.
data (ndarray) – The data array.
quantizer (_type_, optional) – Quantizer to apply to the data array. Defaults to
None
.
- next()
- update_precision(new_precision)
- class hls4ml.model.types.XnorPrecisionType
Bases:
PrecisionType
Convenience class to differentiate ‘regular’ integers from BNN Xnor ones
- hls4ml.model.types.find_minimum_width(data, signed=True)
Helper function to find the minimum integer width to express all entries in the data array without saturation / overflow.
- Parameters:
data (ndarray) – Data array.
signed (bool, optional) – Signed or unsigned type. Defaults to
True.
- Returns:
Minimum integer width required.
- Return type:
int