Exemplo n.º 1
0
    def test_conv2d_api(self, batch_size, in_channels_per_group, H, W,
                        out_channels_per_group, groups, kernel_h, kernel_w,
                        stride_h, stride_w, pad_h, pad_w, dilation, X_scale,
                        X_zero_point, W_scale, W_zero_point, Y_scale,
                        Y_zero_point, use_bias, use_fused, use_channelwise):
        # Tests the correctness of the conv2d module.
        in_channels = in_channels_per_group * groups
        out_channels = out_channels_per_group * groups
        input_feature_map_size = (H, W)
        kernel_size = (kernel_h, kernel_w)
        stride = (stride_h, stride_w)
        padding = (pad_h, pad_w)
        dilation = (dilation, dilation)
        if torch.backends.quantized.engine == 'qnnpack':
            use_channelwise = False
        if use_fused:
            module_name = "QuantizedConvReLU2d"
            qconv_module = nnq_fused.ConvReLU2d(in_channels,
                                                out_channels,
                                                kernel_size,
                                                stride,
                                                padding,
                                                dilation,
                                                groups,
                                                use_bias,
                                                padding_mode="zeros")
        else:
            module_name = "QuantizedConv2d"
            qconv_module = nnq.Conv2d(in_channels,
                                      out_channels,
                                      kernel_size,
                                      stride,
                                      padding,
                                      dilation,
                                      groups,
                                      use_bias,
                                      padding_mode="zeros")

        conv_module = nn.Conv2d(in_channels,
                                out_channels,
                                kernel_size,
                                stride,
                                padding,
                                dilation,
                                groups,
                                use_bias,
                                padding_mode="zeros")
        if use_fused:
            relu_module = nn.ReLU()
            conv_module = nni.ConvReLU2d(conv_module, relu_module)
        conv_module = conv_module.float()

        self._test_conv_api_impl(
            module_name, qconv_module, conv_module, batch_size,
            in_channels_per_group, input_feature_map_size,
            out_channels_per_group, groups, kernel_size, stride, padding,
            dilation, X_scale, X_zero_point, W_scale, W_zero_point, Y_scale,
            Y_zero_point, use_bias, use_fused, use_channelwise)
 def test_conv2d_relu(self):
     module = nniq.ConvReLU2d(3,
                              3,
                              kernel_size=3,
                              stride=1,
                              padding=0,
                              dilation=1,
                              groups=1,
                              bias=True,
                              padding_mode="zeros")
     self._test_op(module, input_size=[1, 3, 6, 6], generate=False)
Exemplo n.º 3
0
 def test_conv2d_relu(self):
     for i, qengine in enumerate(supported_qengines):
         with override_quantized_engine(qengine):
             module = nniq.ConvReLU2d(3, 3, kernel_size=3, stride=1, padding=0, dilation=1,
                                      groups=1, bias=True, padding_mode="zeros")
             self._test_op(module, input_size=[1, 3, 6, 6], generate=False, iter=i)