tvm.relay.analysis
The Relay IR namespace containing the analysis passes.
Classes:
|
Class to represent a relay expression split into regions. |
|
Class to represent a call graph. |
|
The features a program might contain. |
Functions:
|
Determine the number of layers of specified ops in a graph. |
|
Collect set of all data types used in expr. |
|
Get all type variables from expression/type e |
|
Get all vars from expression expr in post-DFS order. |
|
Get bound type variables from expression/type e |
|
Get bound vars from expression expr in post-DFS order. |
Check whether an expression is in the basic block form |
|
|
Check whether an expression is constant |
|
Check that the type is well kinded and return the kind. |
|
Construct a CPU device |
|
Detect the feature used in a relay program. |
Pass to extract IRModule of only fused primitive functions. |
|
|
Extract Relay Expr by its expression ID |
|
Get free type variables from expression/type e |
|
Get free Vars from expression expr in Post DFS order. |
|
Get the calibration data of a given relay graph |
|
Count the number of MACs (multiply-accumulate) of a model |
Pass to extract fake quantized op names and the frequency that they appear in fake quantized regions of an IRModule. |
|
|
Pass to extract unique operator names and how frequently they appear in an IRModule. |
|
Recursively visit the ir in post DFS order node, apply fvisit. |
|
Search fc weight name in the patten: y = nn.dense(x, transpose(w, [1, 0])) |
|
Finds cases that the match expression does not catch, if any. |
|
Check that each Var is only bound once (well formed). |
- class tvm.relay.analysis.AnnotatedRegionSet(expr, region_begin_op, region_end_op)
Class to represent a relay expression split into regions.
Methods:
get_region
(expr)Get the region an expression belongs to.
- get_region(expr)
Get the region an expression belongs to.
- Parameters:
expr (tvm.relay.Expr) – The expression.
- Returns:
The region containing the expression. None if not found.
- Return type:
region
- class tvm.relay.analysis.CallGraph(module)
Class to represent a call graph.
Attributes:
Return the contained Relay IR module.
Methods:
ref_count
(var)Return the number of references to the global var
global_call_count
(var)Return the number of global function calls from a given global var.
is_recursive
(var)Return if the function corresponding to a var is a recursive function.
print_var
(var)Print a call graph of a global function by name or by variable.
- property module
Return the contained Relay IR module.
- Parameters:
None
- Returns:
ret – The contained IRModule
- Return type:
- ref_count(var)
Return the number of references to the global var
- Parameters:
var (Union[String, tvm.relay.GlobalVar])
- Returns:
ret – The number reference to the global var
- Return type:
- global_call_count(var)
Return the number of global function calls from a given global var.
- Parameters:
var (Union[String, tvm.relay.GlobalVar])
- Returns:
ret – The number of global function calls from the given var.
- Return type:
- is_recursive(var)
Return if the function corresponding to a var is a recursive function.
- Parameters:
var (Union[String, tvm.relay.GlobalVar])
- Returns:
ret – If the function corresponding to var is recurisve.
- Return type:
Boolean
- print_var(var)
Print a call graph of a global function by name or by variable.
- Parameters:
var (Union[String, tvm.relay.GlobalVar]) – The name or global variable.
- Returns:
ret – The call graph represented in string.
- Return type:
String
- tvm.relay.analysis.count_layers(expr, valid_ops)
Determine the number of layers of specified ops in a graph. This pass computes only the deepest chain of ops rather than the total number of ops in a graph. Thus, if there are two parallel convolutions (for example), they would be considered a single layer.
- class tvm.relay.analysis.Feature(value)
The features a program might contain.
Attributes:
Whether any non-atom fragment of the program is shared, making the program a graph.
Whether there is local fixpoint in the program.
- fMatch = 14
Whether any non-atom fragment of the program is shared, making the program a graph.
- fGraph = 15
Whether there is local fixpoint in the program.
- tvm.relay.analysis.all_dtypes(expr)
Collect set of all data types used in expr.
- Parameters:
expr (tvm.relay.Expr) – The input expression
- Returns:
ret – Set of data types used in the expression (e.g., {‘int8’, ‘int32’})
- Return type:
Set[String]
- tvm.relay.analysis.all_type_vars(expr, mod=None)
Get all type variables from expression/type e
- Parameters:
expr (Union[tvm.relay.Expr,tvm.relay.Type]) – The input expression/type
mod (Optional[tvm.IRModule]) – The global module
- Returns:
free – The list of all type variables in post-DFS order
- Return type:
List[tvm.relay.TypeVar]
- tvm.relay.analysis.all_vars(expr)
Get all vars from expression expr in post-DFS order.
- Parameters:
expr (tvm.relay.Expr) – The input expression
- Returns:
free – The list of all variables in post-DFS order.
- Return type:
List[tvm.relay.Var]
- tvm.relay.analysis.bound_type_vars(expr, mod=None)
Get bound type variables from expression/type e
- Parameters:
expr (Union[tvm.relay.Expr,tvm.relay.Type]) – The input expression/type
mod (Optional[tvm.IRModule]) – The global module
- Returns:
free – The list of bound type variables in post-DFS order
- Return type:
List[tvm.relay.TypeVar]
- tvm.relay.analysis.bound_vars(expr)
Get bound vars from expression expr in post-DFS order.
- Parameters:
expr (tvm.relay.Expr) – The input expression
- Returns:
free – The list of bound variables in post-DFS order.
- Return type:
List[tvm.relay.Var]
- tvm.relay.analysis.check_basic_block_normal_form(expr)
Check whether an expression is in the basic block form
- Parameters:
expr (tvm.relay.Expr) – The input expression
- Returns:
result – Whether the expression is in the basic block form.
- Return type:
- tvm.relay.analysis.check_constant(expr)
Check whether an expression is constant
- Parameters:
expr (tvm.relay.Expr) – The input expression
- Returns:
result – Whether the expression is constant.
- Return type:
- tvm.relay.analysis.check_kind(t, mod=None)
Check that the type is well kinded and return the kind. For example, this mean type cannot has tensor of tensor, or is a tuple type of 2 shapes.
- Parameters:
t (tvm.relay.Type) – The type to check
mod (Optional[tvm.IRModule]) – The global module.
- Returns:
kind – the kind of t
- Return type:
Kind
Examples
assert check_kind(relay.TupleType([relay.TypeParam('tp1', relay.Kind.Shape)])) == Shape assert check_kind(relay.TupleType([relay.TypeParam('tp1', relay.Kind.Type)])) == Type
- tvm.relay.analysis.cpu(dev_id=0)
Construct a CPU device
- Parameters:
dev_id (int, optional) – The integer device id
- Returns:
dev – The created device
- Return type:
Device
- tvm.relay.analysis.detect_feature(a, b=None)
Detect the feature used in a relay program.
- Parameters:
a (Union[tvm.relay.Expr, tvm.IRModule]) – The input expression or module.
b (Optional[Union[tvm.relay.Expr, tvm.IRModule]]) – The input expression or module. The two arguments cannot both be expression or module.
- Returns:
features – Features used in the program.
- Return type:
Set[Feature]
- tvm.relay.analysis.extract_fused_functions(mod)
Pass to extract IRModule of only fused primitive functions.
The ExtractFusedFunctions pass invokes SimplifyInference, FuseOps(3), and ExtractFusedFunctions in that order
- Parameters:
mod (tvm.IRModule)
- Returns:
ret – A module containing only fused primitive functions
- Return type:
Dict[int, tvm.relay.function.Function]
- tvm.relay.analysis.extract_intermdeiate_expr(mod, expr_id)
Extract Relay Expr by its expression ID
This function is used for extracting Relay Expr by its expression ID of the main function that we can see in print(mod[“main”]).
- Parameters:
mod (tvm.IRModule)
expr_id (the Expr ID that we want to extract)
- Returns:
ret
- Return type:
Extracted IRModule
Examples
# Suppose our module is printed like this: # def @main(%x: Tensor[(1, 1, 5, 1), float32], %w1, %w2) { # %0 = nn.conv2d(%x, %w1, padding=[1, 1, 1, 1], channels=1, kernel_size=[3, 3]); # %1 = nn.conv2d(%0, %w2, padding=[1, 1, 1, 1], channels=1, kernel_size=[3, 3]); # %2 = add(%0, %1); # %3 = split(%2, indices_or_sections=1); # %4 = %3.0; # add(%4, 1f) # } # if we want to extract `%1 = nn.conv2d` from tvm import relay relay.analysis.extract_intermdeiate_expr(mod, 1)
- tvm.relay.analysis.free_type_vars(expr, mod=None)
Get free type variables from expression/type e
- Parameters:
expr (Union[tvm.relay.Expr,tvm.relay.Type]) – The input expression/type
mod (Optional[tvm.IRModule]) – The global module
- Returns:
free – The list of free type variables in post-DFS order
- Return type:
List[tvm.relay.TypeVar]
- tvm.relay.analysis.free_vars(expr)
Get free Vars from expression expr in Post DFS order.
- Parameters:
expr (tvm.relay.Expr) – The input expression
- Returns:
free – The list of free variables in post DFS order.
- Return type:
List[tvm.relay.Var]
Note
The fact that Vars are post-DFS ordred are useful in neural networks: usually this means weights of previous are ordered first.
- tvm.relay.analysis.get_calibration_data(mod, data)
Get the calibration data of a given relay graph
This pass uses the graph executor to get the calibration data of a module, which includes the input and output values of each function. The returned data uses the GlobalVar of each function as a key. Users can further access the inputs and outputs by using inputs or outputs as the key.
Following are some limitations: 1. The input module (graph) cannot have control flows. 2. The input arguments of each function cannot be tuples (outputs can be tuples). 3. We only handle top-level functions (i.e., nested function is not handled). 4. We only handle functions with Compiler attribute being set.
- tvm.relay.analysis.get_total_mac_number(expr)
Count the number of MACs (multiply-accumulate) of a model
- Parameters:
expr (tvm.relay.Expr) – The input expression.
- Returns:
result – The number of MACs (multiply-accumulate) of a model
- Return type:
int64
- tvm.relay.analysis.list_fake_quantized_op_freqs(mod)
Pass to extract fake quantized op names and the frequency that they appear in fake quantized regions of an IRModule.
- tvm.relay.analysis.list_op_freqs(mod)
Pass to extract unique operator names and how frequently they appear in an IRModule. Fused functions are traversed to count the operators that compose them.
- tvm.relay.analysis.post_order_visit(expr, fvisit)
Recursively visit the ir in post DFS order node, apply fvisit. Each node is guaranteed to be visited only once.
- Parameters:
expr (tvm.relay.Expr) – The input expression.
fvisit (function) – The visitor function to be applied.
- tvm.relay.analysis.search_fc_transpose(expr)
Search fc weight name in the patten: y = nn.dense(x, transpose(w, [1, 0]))
This function is used in the data_dep_optimization.simplify_fc_transpose method
- Parameters:
expr (tvm.relay.Expr)
- Returns:
ret – Array of weight variable name in pattern y = nn.dense(x, transpose(w, [1, 0]))
- Return type:
Array[String]
- tvm.relay.analysis.unmatched_cases(match, mod=None)
Finds cases that the match expression does not catch, if any.
- Parameters:
match (tvm.relay.Match) – The match expression
mod (Optional[tvm.IRModule]) – The module (defaults to an empty module)
- Returns:
missing_patterns – Patterns that the match expression does not catch.
- Return type:
[tvm.relay.Pattern]