# Supported Frameworks We support almost all the commonly used Machine Learning frameworks & libraries such as ONNX, PyTorch, Keras, TensorFlow, and TensorFlow Lite. ![Supported deep-learning frameworks](../res/image/supported_frameworks_new.png "Supported deep-learning frameworks") # Mobilint IR Operations List - The following list includes only the operations natively supported by Mobilint hardware. Operations not explicitly listed may still be partially supported during compilation via graph-level transformations into equivalent operations. - All operations supported by Mobilint hardware support the `NHWC`(channel-last)-data format with a batch size of `1`. | Operation | Notes | | :----------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | AddPartial | num inputs: 2
num outputs: 1
attributes:
- is_input0_larger: bool | | AddingConstant | num inputs: 1
num outputs: 1
attributes:
- constant: Weight
- is_const_first: bool (default=false) | | Adding | num inputs: 2
num outputs: 1
| | Batchnorm | num inputs: 1
num outputs: 1
attributes:
- gamma: Weight
- beta: Weight
- moving_mean: Weight
- moving_var: Weight
- epsilon: Weight
- channel_last: bool (default=true) | | Celu | num inputs: 1
num outputs: 1
attributes:
- alpha: float32 | | Clip | num inputs: 1
num outputs: 1
attributes:
- clip_max_value: float32 (optional)
- clip_min_value: float32 (optional) | | Concatenate | num inputs: variable
num outputs: 1
attributes:
- original_key: str (optional)
- axis: int32 (optional)
- original_axis: int32 (optional)
- original_inputs: int32[] (optional)
- input_index: int32[] (optional)
- input_names: str[] (optional)

description:
input_names: input activation names in original order. input_index: input index in computation order. | | Convolution | num inputs: 1
num outputs: 1
attributes:
- in_channels: int32
- out_channels: int32
- h_kernel: int32
- w_kernel: int32
- h_stride: int32
- w_stride: int32
- h_dilation: int32
- w_dilation: int32
- west_padding: int32
- east_padding: int32
- north_padding: int32
- south_padding: int32
- padding_list: int32[] (default=[])
- group_number: int32
- weight: Weight
- bias: Weight (optional)
- channel_last: bool (default=true) | | DepthwiseConvolution | num inputs: 1
num outputs: 1
attributes:
- in_channels: int32
- out_channels: int32
- h_kernel: int32
- w_kernel: int32
- h_stride: int32
- w_stride: int32
- h_dilation: int32
- w_dilation: int32
- west_padding: int32
- east_padding: int32
- north_padding: int32
- south_padding: int32
- padding_list: int32[] (default=[])
- group_number: int32
- weight: Weight
- bias: Weight (optional)
- channel_last: bool (default=true) | | DeviceBridge | num inputs: 1
num outputs: 1
attributes:
- squeeze_axes: int32[]
- unsqueeze_axes: int32[]
- permute_axes: int64[]
- device: str (optional) | | DivConstant | num inputs: 1
num outputs: 1
attributes:
- constant: Weight
- is_const_first: bool | | Div | num inputs: 2
num outputs: 1
| | Elu | num inputs: 1
num outputs: 1
attributes:
- leaky_alpha: float32 | | Erf | num inputs: 1
num outputs: 1
| | Exp | num inputs: 1
num outputs: 1
| | Gelu | num inputs: 1
num outputs: 1
attributes:
- approximate: bool (default=false) | | GLU | num inputs: 1
num outputs: 1
| | GroupConvolution | num inputs: 1
num outputs: 1
attributes:
- in_channels: int32
- out_channels: int32
- h_kernel: int32
- w_kernel: int32
- h_stride: int32
- w_stride: int32
- h_dilation: int32
- w_dilation: int32
- west_padding: int32
- east_padding: int32
- north_padding: int32
- south_padding: int32
- padding_list: int32[] (default=[])
- group_number: int32
- weight: Weight
- bias: Weight (optional)
- channel_last: bool (default=true) | | GroupNormalization | num inputs: 1
num outputs: 1
attributes:
- num_groups: int32
- scale: Weight
- bias: Weight (optional)
- epsilon: Weight
- channel_last: bool (default=true) | | HardSigmoid | num inputs: 1
num outputs: 1
attributes:
- alpha: float32 (optional)
- beta: float32 (optional) | | Hardtanh | num inputs: 1
num outputs: 1
attributes:
- min_val: float32 (default=-1.0)
- max_val: float32 (default=1.0) | | HardSwish | num inputs: 1
num outputs: 1
| | HeaderView | num inputs: 1
num outputs: 1
attributes:
- view_shape: int32[] (default=[])
- num_heads: int32 (default=-1)
- batch_order: int32 (default=0)

description:
HeaderView simplifies the following sequence of operations.
If batch_order == 0
(n,h,w,c)-[reshape]->(1, h, w, num_heads c/num_heads)
-[transpose01324]->(1, h, num_heads, w, c/num_heads)
-[reshape]->(1, h*num_heads, w, c/num_heads)
If batch_order == 1
(n,h,w,c)-[reshape]->(1, h, w, num_heads, c/num_heads)
-[transpose03124]->(1, num_heads, h, w, c/num_heads)
-[reshape]->(1, num_heads*h, w, c/num_heads) | | HeaderViewRevert | num inputs: 1
num outputs: 1
attributes:
- revert_shape: int32[] (default=[])
- num_heads: int32 (default=-1)
- batch_order: int32 (default=0)

description:
HeaderViewRevert simplifies the following sequence of operations.
If batch_order == 0
(n,h,w,c)-[reshape]->(1, h/num_heads, num_heads, w, c)
-[transpose01324]->(1, h/num_heads, w, num_heads, c)
-[reshape]->(1, h/num_heads, w, num_heads * c)
If batch_order == 1
(n,h,w,c)-[reshape]->(1, num_heads, h/num_heads, w, c)
-[transpose02314]->(1, h/num_heads, w, num_heads, c)
-[reshape]->(1, h/num_heads, w, num_heads*c) | | Identity | num inputs: 1
num outputs: 1
| | InputConstant | num inputs: 0
num outputs: 1
attributes:
- constant: Weight | | Input | num inputs: 1
num outputs: 1
| | InstanceNormalization | num inputs: 1
num outputs: 1
attributes:
- scale: Weight
- bias: Weight (optional)
- epsilon: Weight
- channel_last: bool (default=true)
- num_groups: int32 (default=-1)
- group_order: int32 (default=-1)

description:
If `num_groups` and `order` are specified, the channel dimension is grouped and rearranged before normalization.
For example, the following sequence:
(n, 1, w, c*2)-[reshape]->(n, w, c, 2)
-[transpose0312]->(n, 2, w, c)
-[InstanceNorm, num_features=c]->(n, 2, w, c)
-[transpose0231]->(n, w, c, 2)
-[reshape]->(n, 1, w, c*2)
is equivalent to a single operation:
(n, 1, w, c*2)-[InstanceNormalization, num_features=c, num_groups=2, group_order=1]->(n, 1, w, c*2)
The follosing sequence:
(n, 1, w, 2*c)-[reshape]->(n,w,2,c)
-[InstanceNorm, num_features=c]->(n, w, 2, c)
-[reshape]v(n, 1, w, c*2)
is equivalent to a single operation:
(n, 1, w, 2*c)-[InstanceNormalization, num_features=c, num_groups=2, group_order=0]->(n, 1, w, 2*c) | | L1Normalization | num inputs: 1
num outputs: 1
attributes:
- norm_axis: int32[] | | L2Normalization | num inputs: 1
num outputs: 1
attributes:
- norm_axis: int32[]
- epsilon: Weight (optional) | | LSTM | num inputs: variable
num outputs: 1
attributes:
- W: Weight
- R: Weight
- B: Weight (optional)
- lstm_group: str
- input_mask: str
- output_mask: str
- P: Weight (optional)
- direction: str (default="forward")
- batch_first: bool (default=false)
- hidden_size: int32

description:
inputs:[input, sequence_lens, initial_h, initial_c]
outputs:[output] or [hidden_out] or [cell_out]
input_mask: "ishc" or "i", etc,...
output_mask: "o" or "h" or "c" | | LayerNormalization | num inputs: 1
num outputs: 1
attributes:
- normalized_shape: int64[] (default=[])
- scale: Weight
- bias: Weight (optional)
- epsilon: Weight | | Logit | num inputs: 1
num outputs: 1
attributes:
- eps: float32 (optional)

description:
Compute y = ln(z / (1 - z)). If eps is given, we clamp input z = clamp(z, min=eps, max=1-eps) | | RNN | num inputs: variable
num outputs: 1
attributes:
- W: Weight
- R: Weight
- B: Weight (optional)
- rnn_group: str
- input_mask: str
- output_mask: str
- direction: str (default="forward")
- batch_first: bool (default=false)
- hidden_size: int32

description:
inputs:[input, sequence_lens, initial_h]
outputs:[output] or [hidden_out]
input_mask: "ish" or "i", etc,...
output_mask: "o" or "h" | | GRU | num inputs: variable
num outputs: 1
attributes:
- W: Weight
- R: Weight
- B: Weight (optional)
- gru_group: str
- input_mask: str
- output_mask: str
- direction: str (default="forward")
- batch_first: bool (default=false)
- linear_before_reset: bool (default=false)
- hidden_size: int32

description:
inputs:[input, sequence_lens, initial_h]
outputs:[output] or [hidden_out]
input_mask: "ish" or "i", etc,...
output_mask: "o" or "h" | | LeakyRelu | num inputs: 1
num outputs: 1
attributes:
- leaky_alpha: float32 | | Log | num inputs: 1
num outputs: 1
| | LogSigmoid | num inputs: 1
num outputs: 1
| | MatMul | num inputs: variable
num outputs: 1
attributes:
- constant: Weight (optional)
- is_const_first: bool (default=false)
- repeat: int32[2] (default=[-1, -1])

description:
If repeat=(0, 4), then input0 is repeated 4 times along the h-direction.
For example, you can perform a matrix multiplication with input0 of shape (1, 8, 52, 64) and
input1 of shape (1, 32, 52, 64) by concatenating input0 4 times, resulting in a input0 shape of (1, 32, 52, 64). | | Mish | num inputs: 1
num outputs: 1
| | MultiplyConstant | num inputs: 1
num outputs: 1
attributes:
- constant: Weight
- is_const_first: bool (default=false) | | Multiply | num inputs: 2
num outputs: 1
| | Neg | num inputs: 1
num outputs: 1
| | Output | num inputs: 1
num outputs: 1
| | Pad | num inputs: 1
num outputs: 1
attributes:
- west_padding: int32 (default=-1)
- east_padding: int32 (default=-1)
- south_padding: int32 (default=-1)
- north_padding: int32 (default=-1)
- pad_mode: str
- constant: float32 (default=0.0)
- padding_list: int32[] (optional)

description:
padding_list format should be [x1_begin, x2_begin, …, x1_end, x2_end,…],
where xi_begin is the number of pad values added at the beginning of axis | | Pooling | num inputs: 1
num outputs: 1
attributes:
- h_kernel: int32
- w_kernel: int32
- h_stride: int32
- w_stride: int32
- h_dilation: int32 (default=1)
- w_dilation: int32 (default=1)
- west_padding: int32
- east_padding: int32
- north_padding: int32
- south_padding: int32
- padding_list: int32[] (default=[])
- pool_type: str
- pad_mode: str
- is_ceil_mode: bool (default=false)
- is_include_pad: bool (default=false)
- channel_last: bool (default=true) | | GlobalAveragePooling | num inputs: 1
num outputs: 1
attributes:
- channel_last: bool (default=true) | | Pow | num inputs: 1
num outputs: 1
attributes:
- exponent: float32 | | QuickGelu | num inputs: 1
num outputs: 1
| | ReduceL2 | num inputs: 1
num outputs: 1
attributes:
- keep_dims: bool
- reduce_axes: int32[]
- noop_with_empty_axes: int32 | | ReduceMax | num inputs: 1
num outputs: 1
attributes:
- keep_dims: bool
- reduce_axes: int32[]
- noop_with_empty_axes: int32 | | ReduceMean | num inputs: 1
num outputs: 1
attributes:
- keep_dims: bool
- reduce_axes: int32[]
- noop_with_empty_axes: int32 | | ReduceProd | num inputs: 1
num outputs: 1
attributes:
- keep_dims: bool
- reduce_axes: int32[]
- noop_with_empty_axes: int32 | | ReduceSum | num inputs: 1
num outputs: 1
attributes:
- keep_dims: bool
- reduce_axes: int32[]
- noop_with_empty_axes: int32 | | Relu | num inputs: 1
num outputs: 1
| | Reshape | num inputs: 1
num outputs: 1
attributes:
- new_shape: int32[] (optional)
- allowzero: int32 (default=0)
- is_const_first: bool (default=false) | | Resize | num inputs: 1
num outputs: 1
attributes:
- resize_type: str (optional)
- resize_mode: str (optional)
- nearest_mode: str (optional)
- transform_mode: str (optional)
- roi: int32[] (optional)
- scales: float32[] (optional)
- sizes: int32[] (optional)
- cubic_coeff_a: float32 (optional)
- exclude_outside: int32 (optional)
- extrapolation_value: float32 (optional)
- antialias: int32 (optional)
- axes: int32[] (optional)
- keep_aspect_ratio_policy: str (optional) | | RmsNormalization | num inputs: 1
num outputs: 1
attributes:
- normalized_shape: int64[] (default=[])
- epsilon: Weight
- scale: Weight | | Rsqrt | num inputs: 1
num outputs: 1
| | Rstd | num inputs: 1
num outputs: 1
attributes:
- reduce_axes: int32[]
- epsilon: Weight
- num_groups: int32 (default=1)

description:
computes 1/std(x). if gruops > 1, then activation is grouped along channel axis. | | Sigmoid | num inputs: 1
num outputs: 1
attributes:
- alpha: float32 (default=1.0)

description:
alpha is added to deal with more general case like 1 / (1 + exp(-alpha * x)) | | Slice | num inputs: 1
num outputs: 1
attributes:
- axis: int32[]
- start: int64[]
- end: int64[]
- step: int64[] (optional) | | Softmax | num inputs: 1
num outputs: 1
attributes:
- beta: float32 (default=1.0)
- axis: int32 | | Softplus | num inputs: 1
num outputs: 1
| | Sqrt | num inputs: 1
num outputs: 1
| | StaggeredPadding | num inputs: 1
num outputs: 1
attributes:
- axis: int32 (default=3)
- reverse: bool (default=false)
- window_size: int32 (default=-1)

description:
StaggeredPadding does the following:
[[[[1,1,1],
[2,2,2],
[3,3,3],
[4,4,4]]
[5,5,5]]]]
=> [[[[1,1,1,0,0,0,0],
[0,2,2,2,0,0,0],
[0,0,3,3,3,0,0],
[0,0,0,4,4,4,0],
[0,0,0,0,5,5,5]]]]
That is, each original row is shifted to the right so that its non-zero block lies on a “diagonal,” and all other elements are zero-padded.
Then slice last dim by (2*window_size + 1). For example, if window_size=1 in the above, 5=2*1+1 elements are sliced.
=> [[[[1,1,0,0,0],
[2,2,2,0,0],
[0,3,3,3,0],
[0,0,4,4,4],
[0,0,0,5,5]]]]
If reverse
[[[[1,1,1],
[2,2,2],
[3,3,3],
[4,4,4]]
[5,5,5]]]]
=> [[[[0,0,0,0,1,1,1],
[0,0,0,2,2,2,0],
[0,0,3,3,3,0,0],
[0,4,4,4,0,0,0],
[5,5,5,0,0,0,0]]]] | | StatefulAttentionMaskWrapper | num inputs: 1
num outputs: 1
attributes:
- past_seqlen: int32 (default=0)
- is_sliding: bool (default=false)
- sliding_window: int32 (default=1024)
- mask_type: str (default="causal_mask")

description:
mask_type: "causal_mask", "padding_mask" | | StatefulKVCacheWrapper | num inputs: 1
num outputs: 1
attributes:
- cache_name: str
- past_seqlen: int32 (default=0)
- is_sliding: bool (default=false)
- sliding_window: int32 (default=1024)
- max_cache_len: int32 (default=8192) | | StatefulCausalConvCacheWrapper | num inputs: 1
num outputs: 1
attributes:
- cache_name: str
- cache_len: int32 (default=0) | | StatefulLSTMWrapper | num inputs: variable
num outputs: 3
attributes:
- W: Weight
- R: Weight
- B: Weight (optional)
- input_mask: str
- output_mask: str
- P: Weight (optional)
- direction: str (default="forward")
- batch_first: bool (default=false)
- hidden_size: int32
- hidden_state_name: str
- cell_state_name: str
- subgraph: str

description:
When input_mask is `ishc`, then inputs are [input, sequence_lens, initial_h, initial_c],
and if input_mask is `ihc`, then inputs are [input, initial_h, initial_c].
The output_mask is `h` means that among [output, hidden_out, cell_out], only the hidden_out is being used. | | StatefulRNNWrapper | num inputs: variable
num outputs: 2
attributes:
- W: Weight
- R: Weight
- B: Weight (optional)
- input_mask: str
- output_mask: str
- direction: str (default="forward")
- batch_first: bool (default=false)
- hidden_size: int32
- hidden_state_name: str
- subgraph: str

description:
When input_mask is `ish`, then inputs are [input, sequence_lens, initial_h],
and if input_mask is `ih`, then inputs are [input, initial_h].
The output_mask is `h` means that among [output, hidden_out], only the hidden_out is being used. | | StatefulGRUWrapper | num inputs: variable
num outputs: 2
attributes:
- W: Weight
- R: Weight
- B: Weight (optional)
- input_mask: str
- output_mask: str
- direction: str (default="forward")
- batch_first: bool (default=false)
- linear_before_reset: bool (default=false)
- hidden_size: int32
- hidden_state_name: str
- subgraph: str

description:
When input_mask is `ish`, then inputs are [input, sequence_lens, initial_h],
and if input_mask is `ih`, then inputs are [input, initial_h].
The output_mask is `h` means that among [output, hidden_out], only the hidden_out is being used. | | StatefulRoPEWrapper | num inputs: 3
num outputs: 1
attributes:
- rope_type: int32 (default=0)
- seqlen: int32 (default=0)
- rotary_emb_dim: int32 (default=2)

description:
StatefulRoPEWrapper
inputs: (q_or_k, con, sin)
outputs: (q_or_k_embed)
rope_type=> 0: llama, 1: cohere2(aya-vision) | | SubConstant | num inputs: 1
num outputs: 1
attributes:
- constant: Weight
- is_const_first: bool | | Sub | num inputs: 2
num outputs: 1
| | Swish | num inputs: 1
num outputs: 1
| | Tanh | num inputs: 1
num outputs: 1
| | TransposeConvolution | num inputs: 1
num outputs: 1
attributes:
- in_channels: int32
- out_channels: int32
- h_kernel: int32
- w_kernel: int32
- h_stride: int32
- w_stride: int32
- h_dilation: int32
- w_dilation: int32
- west_padding: int32
- east_padding: int32
- north_padding: int32
- south_padding: int32
- padding_list: int32[] (default=[])
- og_padding_list: int32[] (default=[])
- og_out_padding_list: int32[] (default=[])
- group_number: int32
- weight: Weight
- bias: Weight (optional)
- channel_last: bool (default=true) | | Transpose | num inputs: 1
num outputs: 1
attributes:
- transpose_axes: int64[] | | Weightedsum | num inputs: 2
num outputs: 1
attributes:
- weight0: Weight
- weight1: Weight | | OrderedPatchify | num inputs: 1
num outputs: 1
attributes:
- h_kernel: int32
- w_kernel: int32
- order: int32 (default=0)

description:
This operation splits a 4D input tensor into non-overlapping patches and rearranges them into a sequence
according to the specified order. Supports row-major (order=0) and column-major (order=1) layouts.
If order=0 (row-major), the equivalent is: 256 patches, each 12x12, (h_kernel=w_kernel=12)
(1,192,192,64)-[reshape]->(1,16,12,16,12,64)-[transpose 013245]->(1,16,16,12,12,64)-[reshape]->(1,256,144,64)
Note that order0 is its own inverse.
If order=1 (column-major), the equivalent is: 144 patches, each 16x16, (h_kernel=w_kernel=12)
(1,192,192,64)-[reshape]->(1,16,12,16,12,64)-[transpose 024135]->(1,12,12,16,16,64)-[reshape]->(1,144,256,64)
if order=2 (reversing order=1), h_kernel=12, w_kernel=16
(1,144,256,64)-[reshape]->(1,12,12,16,16,64)-[transpose 031425]->(1,16,12,16,12,64)-[reshape]->(1,192,192,64) |