Skip to content

Commit 07167a0

Browse files
authored
Cortex-M: Add transpose conv2d operator (pytorch#16573)
### Summary Add quantized transpose convolution operator for the Cortex-M backend using CMSIS-NN's arm_transpose_conv_wrapper_s8 function. Fixes pytorch#16106 ### Test plan ``` ./backends/cortex_m/test/build_test_runner.sh pytest --config-file=backends/arm/test/pytest.ini backends/cortex_m/test/ops/test_conv_transpose.py ```
1 parent 4a72198 commit 07167a0

9 files changed

Lines changed: 896 additions & 2 deletions

File tree

‎backends/cortex_m/CMakeLists.txt‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,7 @@ set(_cortex_m_kernels__srcs
6161
${CMAKE_CURRENT_SOURCE_DIR}/ops/op_quantized_depthwise_conv2d.cpp
6262
${CMAKE_CURRENT_SOURCE_DIR}/ops/op_quantized_linear.cpp
6363
${CMAKE_CURRENT_SOURCE_DIR}/ops/op_quantized_mul.cpp
64+
${CMAKE_CURRENT_SOURCE_DIR}/ops/op_quantized_transpose_conv2d.cpp
6465
${CMAKE_CURRENT_SOURCE_DIR}/ops/op_minimum.cpp
6566
${CMAKE_CURRENT_SOURCE_DIR}/ops/op_maximum.cpp
6667
${CMAKE_CURRENT_SOURCE_DIR}/ops/op_softmax.cpp
Lines changed: 251 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,251 @@
1+
/*
2+
* Copyright (c) Meta Platforms, Inc. and affiliates.
3+
* All rights reserved.
4+
*
5+
* This source code is licensed under the BSD-style license found in the
6+
* LICENSE file in the root directory of this source tree.
7+
*/
8+
9+
#include "cortex_m_ops_common.h"
10+
11+
extern "C" {
12+
#include "arm_nnfunctions.h"
13+
}
14+
15+
namespace cortex_m {
16+
namespace native {
17+
18+
using KernelRuntimeContext = torch::executor::KernelRuntimeContext;
19+
20+
namespace {
21+
constexpr int64_t kConvTransposeDim = 4;
22+
23+
bool validate_transpose_conv2d_arguments(
24+
KernelRuntimeContext& context,
25+
const Tensor& input,
26+
const Tensor& weight,
27+
const torch::executor::optional<Tensor>& bias,
28+
const Tensor& output,
29+
const Tensor& requantize_multipliers,
30+
const Tensor& requantize_shifts) {
31+
if (input.dim() != kConvTransposeDim || weight.dim() != kConvTransposeDim ||
32+
output.dim() != kConvTransposeDim) {
33+
ET_LOG(Error, "quantized_transpose_conv2d_out: tensors must be 4-D");
34+
context.fail(Error::InvalidArgument);
35+
return false;
36+
}
37+
38+
if (!is_channels_last_tensor(input)) {
39+
ET_LOG(
40+
Error, "quantized_transpose_conv2d_out: input must be channels_last");
41+
context.fail(Error::InvalidArgument);
42+
return false;
43+
}
44+
45+
if (!is_channels_last_tensor(output)) {
46+
ET_LOG(
47+
Error, "quantized_transpose_conv2d_out: output must be channels_last");
48+
context.fail(Error::InvalidArgument);
49+
return false;
50+
}
51+
52+
if (input.scalar_type() != ScalarType::Char ||
53+
output.scalar_type() != ScalarType::Char) {
54+
ET_LOG(
55+
Error, "quantized_transpose_conv2d_out: input and output must be int8");
56+
context.fail(Error::InvalidArgument);
57+
return false;
58+
}
59+
60+
if (weight.scalar_type() != ScalarType::Char) {
61+
ET_LOG(Error, "quantized_transpose_conv2d_out: weight must be int8");
62+
context.fail(Error::InvalidArgument);
63+
return false;
64+
}
65+
66+
if (bias.has_value() && bias.value().scalar_type() != ScalarType::Int) {
67+
ET_LOG(
68+
Error,
69+
"quantized_transpose_conv2d_out: bias must be int32 if provided");
70+
context.fail(Error::InvalidArgument);
71+
return false;
72+
}
73+
74+
const int64_t out_channels = output.size(1);
75+
if (requantize_multipliers.size(0) != out_channels ||
76+
requantize_shifts.size(0) != out_channels) {
77+
ET_LOG(
78+
Error,
79+
"quantized_transpose_conv2d_out: per-channel params must match output channels (%zd)",
80+
out_channels);
81+
context.fail(Error::InvalidArgument);
82+
return false;
83+
}
84+
85+
return true;
86+
}
87+
} // namespace
88+
89+
Tensor& quantized_transpose_conv2d_out(
90+
KernelRuntimeContext& context,
91+
const Tensor& input,
92+
const Tensor& weight,
93+
const torch::executor::optional<Tensor>& bias,
94+
const Int64ArrayRef stride,
95+
const Int64ArrayRef padding,
96+
const Int64ArrayRef output_padding,
97+
const Int64ArrayRef dilation,
98+
const int64_t input_offset,
99+
const int64_t output_offset,
100+
const Tensor& requantize_multipliers,
101+
const Tensor& requantize_shifts,
102+
const int64_t activation_min,
103+
const int64_t activation_max,
104+
Tensor& out) {
105+
if (!validate_transpose_conv2d_arguments(
106+
context,
107+
input,
108+
weight,
109+
bias,
110+
out,
111+
requantize_multipliers,
112+
requantize_shifts)) {
113+
return out;
114+
}
115+
116+
const int32_t batch = static_cast<int32_t>(input.size(0));
117+
const int32_t input_channels = static_cast<int32_t>(input.size(1));
118+
const int32_t input_height = static_cast<int32_t>(input.size(2));
119+
const int32_t input_width = static_cast<int32_t>(input.size(3));
120+
121+
const int32_t kernel_output_channels = static_cast<int32_t>(weight.size(0));
122+
const int32_t kernel_height = static_cast<int32_t>(weight.size(1));
123+
const int32_t kernel_width = static_cast<int32_t>(weight.size(2));
124+
const int32_t kernel_input_channels = static_cast<int32_t>(weight.size(3));
125+
126+
const int32_t output_channels = static_cast<int32_t>(out.size(1));
127+
const int32_t output_height = static_cast<int32_t>(out.size(2));
128+
const int32_t output_width = static_cast<int32_t>(out.size(3));
129+
130+
if (kernel_output_channels != output_channels) {
131+
ET_LOG(
132+
Error,
133+
"quantized_transpose_conv2d_out: weight output channels (%d) != output channels (%d)",
134+
kernel_output_channels,
135+
output_channels);
136+
context.fail(Error::InvalidArgument);
137+
return out;
138+
}
139+
140+
const int32_t input_offset_val = static_cast<int32_t>(input_offset);
141+
const int32_t output_offset_val = static_cast<int32_t>(output_offset);
142+
const int32_t activation_min_val = static_cast<int32_t>(activation_min);
143+
const int32_t activation_max_val = static_cast<int32_t>(activation_max);
144+
145+
const cmsis_nn_dims input_dims{
146+
batch, input_height, input_width, input_channels};
147+
const cmsis_nn_dims filter_dims{
148+
kernel_output_channels,
149+
kernel_height,
150+
kernel_width,
151+
kernel_input_channels};
152+
const cmsis_nn_dims output_dims{
153+
batch, output_height, output_width, output_channels};
154+
const cmsis_nn_dims bias_dims{1, 1, 1, output_channels};
155+
156+
// Setup transposed convolution parameters
157+
cmsis_nn_transpose_conv_params transpose_conv_params;
158+
transpose_conv_params.input_offset = input_offset_val;
159+
transpose_conv_params.output_offset = output_offset_val;
160+
transpose_conv_params.stride.h = static_cast<const int32_t>(stride[0]);
161+
transpose_conv_params.stride.w = static_cast<const int32_t>(stride[1]);
162+
transpose_conv_params.padding.h = static_cast<const int32_t>(padding[0]);
163+
transpose_conv_params.padding.w = static_cast<const int32_t>(padding[1]);
164+
// padding_offsets corresponds to output_padding in PyTorch
165+
transpose_conv_params.padding_offsets.h =
166+
static_cast<const int32_t>(output_padding[0]);
167+
transpose_conv_params.padding_offsets.w =
168+
static_cast<const int32_t>(output_padding[1]);
169+
transpose_conv_params.dilation.h = static_cast<const int32_t>(dilation[0]);
170+
transpose_conv_params.dilation.w = static_cast<const int32_t>(dilation[1]);
171+
transpose_conv_params.activation.min = activation_min_val;
172+
transpose_conv_params.activation.max = activation_max_val;
173+
174+
cmsis_nn_per_channel_quant_params quant_params;
175+
quant_params.multiplier = requantize_multipliers.data_ptr<int32_t>();
176+
quant_params.shift = requantize_shifts.data_ptr<int32_t>();
177+
178+
const int8_t* input_data = input.const_data_ptr<int8_t>();
179+
const int8_t* weight_data = weight.const_data_ptr<int8_t>();
180+
int8_t* output_data = out.mutable_data_ptr<int8_t>();
181+
const int32_t* bias_data =
182+
bias.has_value() ? bias.value().const_data_ptr<int32_t>() : nullptr;
183+
184+
cmsis_nn_context cmsis_context;
185+
cmsis_context.buf = nullptr;
186+
cmsis_context.size = 0;
187+
188+
cmsis_nn_context output_context;
189+
output_context.buf = nullptr;
190+
output_context.size = 0;
191+
192+
const int32_t buffer_bytes = arm_transpose_conv_s8_get_buffer_size(
193+
&transpose_conv_params, &input_dims, &filter_dims, &output_dims);
194+
auto buffer_or_error = context.allocate_temp(
195+
static_cast<size_t>(buffer_bytes), alignof(int16_t));
196+
if (!buffer_or_error.ok()) {
197+
ET_LOG(
198+
Error,
199+
"quantized_transpose_conv2d_out: failed to allocate scratch buffer (%d bytes, error %d)",
200+
buffer_bytes,
201+
static_cast<int>(buffer_or_error.error()));
202+
context.fail(buffer_or_error.error());
203+
return out;
204+
}
205+
cmsis_context.buf = buffer_or_error.get();
206+
cmsis_context.size = buffer_bytes;
207+
208+
const int32_t output_buffer_bytes =
209+
arm_transpose_conv_s8_get_reverse_conv_buffer_size(
210+
&transpose_conv_params, &input_dims, &filter_dims);
211+
auto output_buffer_or_error = context.allocate_temp(
212+
static_cast<size_t>(output_buffer_bytes), alignof(int16_t));
213+
if (!output_buffer_or_error.ok()) {
214+
ET_LOG(
215+
Error,
216+
"quantized_transpose_conv2d_out: failed to allocate output scratch buffer (%d bytes, error %d)",
217+
output_buffer_bytes,
218+
static_cast<int>(output_buffer_or_error.error()));
219+
context.fail(output_buffer_or_error.error());
220+
return out;
221+
}
222+
output_context.buf = output_buffer_or_error.get();
223+
output_context.size = output_buffer_bytes;
224+
225+
const arm_cmsis_nn_status status = arm_transpose_conv_wrapper_s8(
226+
&cmsis_context,
227+
&output_context,
228+
&transpose_conv_params,
229+
&quant_params,
230+
&input_dims,
231+
input_data,
232+
&filter_dims,
233+
weight_data,
234+
&bias_dims,
235+
bias_data,
236+
&output_dims,
237+
output_data);
238+
239+
if (status != ARM_CMSIS_NN_SUCCESS) {
240+
ET_LOG(
241+
Error,
242+
"quantized_transpose_conv2d_out: arm_transpose_conv_wrapper_s8 failed with status %d",
243+
status);
244+
context.fail(Error::Internal);
245+
}
246+
247+
return out;
248+
}
249+
250+
} // namespace native
251+
} // namespace cortex_m

0 commit comments

Comments
 (0)