Converters

This table contains a list of supported PyTorch methods and their associated converters.

If your model is not converting, a good start in debugging would be to see if it contains a method not listed in this table. You may also find these a useful reference when writing your own converters.

Method	Converter
`torch.abs`	`convert_abs`
`torch.abs_`	`convert_abs`
`torch.acos`	`convert_acos`
`torch.acos_`	`convert_acos`
`torch.add`	`convert_add`
`torch.asin`	`convert_asin`
`torch.asin_`	`convert_asin`
`torch.atan`	`convert_atan`
`torch.atan_`	`convert_atan`
`torch.cat`	`convert_cat`
`torch.ceil`	`convert_ceil`
`torch.ceil_`	`convert_ceil`
`torch.chunk`	`convert_chunk`
`torch.clamp`	`convert_clamp`
`torch.clamp_max`	`convert_clamp_max`
`torch.clamp_min`	`convert_clamp_min`
`torch.clone`	`convert_clone`
`torch.cos`	`convert_cos`
`torch.cos_`	`convert_cos`
`torch.cosh`	`convert_cosh`
`torch.cosh_`	`convert_cosh`
`torch.div`	`convert_div`
`torch.einsum`	`convert_einsum`
`torch.eq`	`convert_gt`
`torch.exp`	`convert_exp`
`torch.exp_`	`convert_exp`
`torch.flatten`	`convert_view`
`torch.floor`	`convert_floor`
`torch.floor_`	`convert_floor`
`torch.floor_divide`	`convert_floordiv`
`torch.fmod`	`convert_mod`
`torch.gt`	`convert_gt`
`torch.instance_norm`	`convert_instance_norm`
`torch.log`	`convert_log`
`torch.log_`	`convert_log`
`torch.lt`	`convert_gt`
`torch.max`	`convert_max`
`torch.max_pool3d`	`convert_max_pool3d`
`torch.mean`	`convert_mean`
`torch.min`	`convert_min`
`torch.mul`	`convert_mul`
`torch.narrow`	`convert_narrow`
`torch.ne`	`convert_ne`
`torch.neg`	`convert_neg`
`torch.neg_`	`convert_neg`
`torch.pow`	`convert_pow`
`torch.prod`	`convert_prod`
`torch.reciprocal`	`convert_reciprocal`
`torch.reciprocal_`	`convert_reciprocal`
`torch.relu`	`convert_functional_relu`
`torch.relu_`	`convert_functional_relu`
`torch.roll`	`convert_roll`
`torch.selu`	`convert_selu`
`torch.selu_`	`convert_selu`
`torch.sigmoid`	`convert_sigmoid`
`torch.sin`	`convert_sin`
`torch.sin_`	`convert_sin`
`torch.sinh`	`convert_sinh`
`torch.sinh_`	`convert_sinh`
`torch.split`	`convert_split`
`torch.sqrt`	`convert_sqrt`
`torch.sqrt_`	`convert_sqrt`
`torch.squeeze`	`convert_view`
`torch.stack`	`convert_cat_trt7`
`torch.sub`	`convert_sub`
`torch.sum`	`convert_sum`
`torch.tan`	`convert_cos`
`torch.tan_`	`convert_cos`
`torch.tanh`	`convert_tanh`
`torch.tensor`	`convert_mod`
`torch.transpose`	`convert_transpose_trt7`
`torch.unsqueeze`	`convert_view`
`torch.Tensor.__add__`	`convert_add`
`torch.Tensor.__div__`	`convert_div`
`torch.Tensor.__eq__`	`convert_gt`
`torch.Tensor.__floordiv__`	`convert_floordiv`
`torch.Tensor.__gt__`	`convert_gt`
`torch.Tensor.__iadd__`	`convert_add`
`torch.Tensor.__idiv__`	`convert_div`
`torch.Tensor.__ifloordiv__`	`convert_floordiv`
`torch.Tensor.__imod__`	`convert_mod`
`torch.Tensor.__imul__`	`convert_mul`
`torch.Tensor.__ipow__`	`convert_pow`
`torch.Tensor.__isub__`	`convert_sub`
`torch.Tensor.__itruediv__`	`convert_div`
`torch.Tensor.__lt__`	`convert_gt`
`torch.Tensor.__mod__`	`convert_mod`
`torch.Tensor.__mul__`	`convert_mul`
`torch.Tensor.__ne__`	`convert_ne`
`torch.Tensor.__neg__`	`convert_neg`
`torch.Tensor.__pow__`	`convert_pow`
`torch.Tensor.__radd__`	`convert_add`
`torch.Tensor.__rdiv__`	`convert_rdiv`
`torch.Tensor.__rmul__`	`convert_mul`
`torch.Tensor.__rpow__`	`convert_pow`
`torch.Tensor.__rsub__`	`convert_sub`
`torch.Tensor.__rtruediv__`	`convert_rdiv`
`torch.Tensor.__sub__`	`convert_sub`
`torch.Tensor.__truediv__`	`convert_div`
`torch.Tensor.abs`	`convert_abs`
`torch.Tensor.abs_`	`convert_abs`
`torch.Tensor.acos`	`convert_acos`
`torch.Tensor.acos_`	`convert_acos`
`torch.Tensor.asin`	`convert_asin`
`torch.Tensor.asin_`	`convert_asin`
`torch.Tensor.atan`	`convert_atan`
`torch.Tensor.atan_`	`convert_atan`
`torch.Tensor.ceil`	`convert_ceil`
`torch.Tensor.ceil_`	`convert_ceil`
`torch.Tensor.chunk`	`convert_chunk`
`torch.Tensor.clamp`	`convert_clamp`
`torch.Tensor.clamp_max`	`convert_clamp_max`
`torch.Tensor.clamp_min`	`convert_clamp_min`
`torch.Tensor.clone`	`convert_clone`
`torch.Tensor.contiguous`	`convert_functional_identity`
`torch.Tensor.cos`	`convert_cos`
`torch.Tensor.cos_`	`convert_cos`
`torch.Tensor.cosh`	`convert_cosh`
`torch.Tensor.cosh_`	`convert_cosh`
`torch.Tensor.exp`	`convert_exp`
`torch.Tensor.exp_`	`convert_exp`
`torch.Tensor.expand`	`convert_expand`
`torch.Tensor.flatten`	`convert_view`
`torch.Tensor.floor`	`convert_floor`
`torch.Tensor.floor_`	`convert_floor`
`torch.Tensor.log`	`convert_log`
`torch.Tensor.log_`	`convert_log`
`torch.Tensor.max`	`convert_max`
`torch.Tensor.mean`	`convert_mean`
`torch.Tensor.min`	`convert_min`
`torch.Tensor.mul_`	`convert_mul`
`torch.Tensor.narrow`	`convert_narrow`
`torch.Tensor.neg`	`convert_neg`
`torch.Tensor.neg_`	`convert_neg`
`torch.Tensor.permute`	`convert_permute`
`torch.Tensor.prod`	`convert_prod`
`torch.Tensor.reciprocal`	`convert_reciprocal`
`torch.Tensor.reciprocal_`	`convert_reciprocal`
`torch.Tensor.relu`	`convert_functional_relu`
`torch.Tensor.reshape`	`convert_view`
`torch.Tensor.roll`	`convert_roll`
`torch.Tensor.sigmoid`	`convert_sigmoid`
`torch.Tensor.sin`	`convert_sin`
`torch.Tensor.sin_`	`convert_sin`
`torch.Tensor.sinh`	`convert_sinh`
`torch.Tensor.sinh_`	`convert_sinh`
`torch.Tensor.split`	`convert_split`
`torch.Tensor.sqrt`	`convert_sqrt`
`torch.Tensor.sqrt_`	`convert_sqrt`
`torch.Tensor.squeeze`	`convert_view`
`torch.Tensor.sum`	`convert_sum`
`torch.Tensor.tan`	`convert_cos`
`torch.Tensor.tan_`	`convert_cos`
`torch.Tensor.unsqueeze`	`convert_view`
`torch.Tensor.view`	`convert_view`
`torch.nn.functional.adaptive_avg_pool2d`	`convert_adaptive_avg_pool2d`
`torch.nn.functional.adaptive_avg_pool3d`	`convert_adaptive_avg_pool3d`
`torch.nn.functional.adaptive_max_pool2d`	`convert_adaptive_max_pool2d`
`torch.nn.functional.adaptive_max_pool3d`	`convert_adaptive_max_pool3d`
`torch.nn.functional.avg_pool2d`	`convert_avg_pool_trt7`
`torch.nn.functional.avg_pool3d`	`convert_avg_pool_trt7`
`torch.nn.functional.batch_norm`	`convert_batch_norm_trt7`
`torch.nn.functional.conv2d`	`convert_Conv_trt7_functional`
`torch.nn.functional.conv3d`	`convert_Conv_trt7_functional`
`torch.nn.functional.dropout`	`convert_functional_identity`
`torch.nn.functional.dropout2d`	`convert_functional_identity`
`torch.nn.functional.dropout3d`	`convert_functional_identity`
`torch.nn.functional.elu`	`convert_elu`
`torch.nn.functional.elu_`	`convert_elu`
`torch.nn.functional.gelu`	`convert_gelu_v1`
`torch.nn.functional.group_norm`	`convert_group_norm`
`torch.nn.functional.instance_norm`	`convert_instance_norm`
`torch.nn.functional.interpolate`	`convert_interpolate_trt7`
`torch.nn.functional.layer_norm`	`convert_layernorm`
`torch.nn.functional.leaky_relu`	`convert_leaky_relu`
`torch.nn.functional.leaky_relu_`	`convert_leaky_relu`
`torch.nn.functional.linear`	`convert_Linear`
`torch.nn.functional.max_pool1d`	`convert_max_pool1d`
`torch.nn.functional.max_pool2d`	`convert_max_pool2d`
`torch.nn.functional.max_pool3d`	`convert_max_pool3d`
`torch.nn.functional.normalize`	`convert_normalize`
`torch.nn.functional.pad`	`convert_pad`
`torch.nn.functional.prelu`	`convert_prelu`
`torch.nn.functional.relu`	`convert_functional_relu`
`torch.nn.functional.relu6`	`convert_functional_relu6`
`torch.nn.functional.relu_`	`convert_functional_relu`
`torch.nn.functional.selu`	`convert_selu`
`torch.nn.functional.selu_`	`convert_selu`
`torch.nn.functional.sigmoid`	`convert_sigmoid`
`torch.nn.functional.silu`	`convert_silu`
`torch.nn.functional.softmax`	`convert_softmax`
`torch.nn.functional.softplus`	`convert_softplus`
`torch.nn.functional.softsign`	`convert_softsign`
`torch.nn.functional.tanh`	`convert_tanh`
`torch.nn.functional.upsample`	`convert_interpolate_trt7`
`torch.nn.AdaptiveAvgPool2d.forward`	`convert_AdaptiveAvgPool2d`
`torch.nn.BatchNorm1d.forward`	`convert_BatchNorm2d`
`torch.nn.Conv3d.forward`	`convert_Conv_trt7`
`torch.nn.Conv2d.forward`	`convert_Conv_trt7`
`torch.nn.Conv1d.forward`	`convert_Conv1d`
`torch.nn.ConvTranspose3d.forward`	`convert_ConvTranspose2d_trt7`
`torch.nn.ConvTranspose2d.forward`	`convert_ConvTranspose2d_trt7`
`torch.nn.LogSoftmax.forward`	`convert_LogSoftmax`
`torch.nn.AdaptiveAvgPool3d.forward`	`convert_AdaptiveAvgPool3d`
`torch.Tensor.__getitem__`	`convert_tensor_getitem`
`torch.nn.Dropout3d.forward`	`convert_identity`
`torch.nn.Dropout2d.forward`	`convert_identity`
`torch.nn.Dropout.forward`	`convert_identity`
`torch.nn.ReLU.forward`	`convert_relu`
`torch.nn.ReLU6.forward`	`convert_relu6`