add resize_type for align_corner

FeiGeChuanShu · FeiGeChuanShu · commit 7462ddb60920 · 2021-08-20T23:40:42.000+08:00
diff --git a/source/device/cpu/op/interp/cortex-a/interp_kernel_arm.c b/source/device/cpu/op/interp/cortex-a/interp_kernel_arm.c
@@ -32,13 +32,21 @@
 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
 
-static void linear_coeffs(int w, int outw, int* xofs, float* alpha)
+static void linear_coeffs(int w, int outw, int* xofs, float* alpha, int align_corner)
 {
     double scale = (double)w / outw;
-
+    if (align_corner)
+    {
+        scale = (double)(w - 1) / (outw - 1);
+    }
     for (int dx = 0; dx < outw; dx++)
     {
-        float fx = (float)((dx)*scale);
+        float fx = (float)((dx + 0.5) * scale - 0.5);
+        if (align_corner)
+        {
+            fx = (float)(dx * scale);
+        }
+
         int sx = floor(fx);
         fx -= sx;
 
@@ -498,7 +506,7 @@ int interp_run(struct tensor* output_tensor, struct tensor* input_tensor, struct
             }
         }
     }
-    else if (resize_type == 2) // bilinear
+    else if (resize_type == 2 || resize_type == 4) // bilinear
     {
         int* buf = (int*)sys_malloc((out_w + out_h + out_w * 2 + out_h * 2) * sizeof(int));
 
@@ -508,8 +516,9 @@ int interp_run(struct tensor* output_tensor, struct tensor* input_tensor, struct
         float* alpha = (float*)(buf + out_w + out_h);            // new float[ow * 2];
         float* beta = (float*)(buf + out_w + out_h + out_w * 2); // new float[oh * 2];
 
-        linear_coeffs(in_w, out_w, xofs, alpha);
-        linear_coeffs(in_h, out_h, yofs, beta);
+        int align_corner = interp_param->resize_type == 2? 0 : 1;
+        linear_coeffs(in_w, out_w, xofs, alpha, align_corner);
+        linear_coeffs(in_h, out_h, yofs, beta, align_corner);
 
 #pragma omp parallel for num_threads(num_thread)
         for (int q = 0; q < in_c; ++q)
diff --git a/source/device/cpu/op/interp/interp_ref.c b/source/device/cpu/op/interp/interp_ref.c
@@ -39,13 +39,21 @@
 
 #define INTERP_MIN(a, b) ((a) < (b) ? (a) : (b))
 
-void linear_coeffs(int w, int outw, int* xofs, float* alpha)
+static void linear_coeffs(int w, int outw, int* xofs, float* alpha, int align_corner)
 {
     double scale = (double)w / outw;
-
+    if (align_corner)
+    {
+        scale = (double)(w - 1) / (outw - 1);
+    }
     for (int dx = 0; dx < outw; dx++)
     {
-        float fx = (float)((dx)*scale);
+        float fx = (float)((dx + 0.5) * scale - 0.5);
+        if (align_corner)
+        {
+            fx = (float)(dx * scale);
+        }
+        
         int sx = floor(fx);
         fx -= sx;
 
@@ -193,7 +201,7 @@ int ref_interp_fp32(struct tensor* input_tensor, struct tensor* output_tensor, s
             }
         }
     }
-    else if (param->resize_type == 2)
+    else if (param->resize_type == 2 || param->resize_type == 4)
     {
         float* input = (float*)input_tensor->data;
         float* output = (float*)output_tensor->data;
@@ -222,8 +230,9 @@ int ref_interp_fp32(struct tensor* input_tensor, struct tensor* output_tensor, s
         float* alpha = (float*)(buf + param->output_width + param->output_height);                          //new float[ow * 2];
         float* beta = (float*)(buf + param->output_width + param->output_height + param->output_width * 2); //new float[oh * 2];
 
-        linear_coeffs(in_w, out_w, xofs, alpha);
-        linear_coeffs(in_h, out_h, yofs, beta);
+        int align_corner = param->resize_type == 2? 0 : 1;
+        linear_coeffs(in_w, out_w, xofs, alpha, align_corner);
+        linear_coeffs(in_h, out_h, yofs, beta, align_corner);
 
         for (int q = 0; q < channel; ++q)
         {
@@ -290,7 +299,7 @@ int ref_interp_int8(struct tensor* input_tensor, struct tensor* output_tensor, s
             }
         }
     }
-    else if (param->resize_type == 2)
+    else if (param->resize_type == 2 || param->resize_type == 4)
     {
         int batch = input_tensor->dims[0];
         int channel = input_tensor->dims[1];
@@ -316,8 +325,9 @@ int ref_interp_int8(struct tensor* input_tensor, struct tensor* output_tensor, s
         float* alpha = (float*)(buf + param->output_width + param->output_height);                          //new float[ow * 2];
         float* beta = (float*)(buf + param->output_width + param->output_height + param->output_width * 2); //new float[oh * 2];
 
-        linear_coeffs(in_w, out_w, xofs, alpha);
-        linear_coeffs(in_h, out_h, yofs, beta);
+        int align_corner = param->resize_type == 2? 0 : 1;
+        linear_coeffs(in_w, out_w, xofs, alpha, align_corner);
+        linear_coeffs(in_h, out_h, yofs, beta, align_corner);
 
         for (int q = 0; q < channel; ++q)
         {
@@ -398,7 +408,7 @@ int ref_interp_uint8(struct tensor* input_tensor, struct tensor* output_tensor,
             }
         }
     }
-    else if (param->resize_type == 2)
+    else if (param->resize_type == 2 || param->resize_type == 4)
     {
         int batch = input_tensor->dims[0];
         int channel = input_tensor->dims[1];
@@ -424,8 +434,9 @@ int ref_interp_uint8(struct tensor* input_tensor, struct tensor* output_tensor,
         float* alpha = (float*)(buf + param->output_width + param->output_height);                          //new float[ow * 2];
         float* beta = (float*)(buf + param->output_width + param->output_height + param->output_width * 2); //new float[oh * 2];
 
-        linear_coeffs(in_w, out_w, xofs, alpha);
-        linear_coeffs(in_h, out_h, yofs, beta);
+        int align_corner = param->resize_type == 2? 0 : 1;
+        linear_coeffs(in_w, out_w, xofs, alpha, align_corner);
+        linear_coeffs(in_h, out_h, yofs, beta, align_corner);
 
         for (int q = 0; q < channel; ++q)
         {
diff --git a/tools/convert_tool/onnx/onnx2tengine.cpp b/tools/convert_tool/onnx/onnx2tengine.cpp
@@ -2136,6 +2136,17 @@ int load_resize(ir_graph_t* graph, ir_node_t* node, const onnx::NodeProto& onnx_
     interp_param->height_scale = 0;
     interp_param->width_scale = 0;
 
+    int align_corner = 0;
+    for (int k = 0; k < onnx_node.attribute_size(); k++)
+    {
+        const onnx::AttributeProto& attr = onnx_node.attribute(k);
+        if (attr.name() == "coordinate_transformation_mode")
+        {
+            if (attr.s() == "align_corners")
+                align_corner = 1;
+        }
+    }
+
     if (onnx_node.input_size() == 1)
     {
         for (int k = 0; k < onnx_node.attribute_size(); k++)
@@ -2198,7 +2209,7 @@ int load_resize(ir_graph_t* graph, ir_node_t* node, const onnx::NodeProto& onnx_
     }
     else if (mode == "bilinear" || mode == "linear")
     {
-        interp_param->resize_type = 2;
+        interp_param->resize_type = align_corner == 0? 2 : 4;
     }
 
     return 0;

Original file line number	Diff line number	Diff line change
`@@ -39,13 +39,21 @@`
`39`	`39`
`40`	`40`	`#define INTERP_MIN(a, b) ((a) < (b) ? (a) : (b))`
`41`	`41`
`42`		`-void linear_coeffs(int w, int outw, int* xofs, float* alpha)`
	`42`	`+static void linear_coeffs(int w, int outw, int* xofs, float* alpha, int align_corner)`
`43`	`43`	`{`
`44`	`44`	`double scale = (double)w / outw;`
`45`		`-`
	`45`	`+ if (align_corner)`
	`46`	`+ {`
	`47`	`+ scale = (double)(w - 1) / (outw - 1);`
	`48`	`+ }`
`46`	`49`	`for (int dx = 0; dx < outw; dx++)`
`47`	`50`	`{`
`48`		`- float fx = (float)((dx)*scale);`
	`51`	`+ float fx = (float)((dx + 0.5) * scale - 0.5);`
	`52`	`+ if (align_corner)`
	`53`	`+ {`
	`54`	`+ fx = (float)(dx * scale);`
	`55`	`+ }`
	`56`	`+`
`49`	`57`	`int sx = floor(fx);`
`50`	`58`	`fx -= sx;`
`51`	`59`
`@@ -193,7 +201,7 @@ int ref_interp_fp32(struct tensor* input_tensor, struct tensor* output_tensor, s`
`193`	`201`	`}`
`194`	`202`	`}`
`195`	`203`	`}`
`196`		`- else if (param->resize_type == 2)`
	`204`	`+ else if (param->resize_type == 2 \|\| param->resize_type == 4)`
`197`	`205`	`{`
`198`	`206`	`float* input = (float*)input_tensor->data;`
`199`	`207`	`float* output = (float*)output_tensor->data;`
`@@ -222,8 +230,9 @@ int ref_interp_fp32(struct tensor* input_tensor, struct tensor* output_tensor, s`
`222`	`230`	`float* alpha = (float)(buf + param->output_width + param->output_height); //new float[ow 2];`
`223`	`231`	`float* beta = (float)(buf + param->output_width + param->output_height + param->output_width 2); //new float[oh * 2];`
`224`	`232`
`225`		`- linear_coeffs(in_w, out_w, xofs, alpha);`
`226`		`- linear_coeffs(in_h, out_h, yofs, beta);`
	`233`	`+ int align_corner = param->resize_type == 2? 0 : 1;`
	`234`	`+ linear_coeffs(in_w, out_w, xofs, alpha, align_corner);`
	`235`	`+ linear_coeffs(in_h, out_h, yofs, beta, align_corner);`
`227`	`236`
`228`	`237`	`for (int q = 0; q < channel; ++q)`
`229`	`238`	`{`
`@@ -290,7 +299,7 @@ int ref_interp_int8(struct tensor* input_tensor, struct tensor* output_tensor, s`
`290`	`299`	`}`
`291`	`300`	`}`
`292`	`301`	`}`
`293`		`- else if (param->resize_type == 2)`
	`302`	`+ else if (param->resize_type == 2 \|\| param->resize_type == 4)`
`294`	`303`	`{`
`295`	`304`	`int batch = input_tensor->dims[0];`
`296`	`305`	`int channel = input_tensor->dims[1];`
`@@ -316,8 +325,9 @@ int ref_interp_int8(struct tensor* input_tensor, struct tensor* output_tensor, s`
`316`	`325`	`float* alpha = (float)(buf + param->output_width + param->output_height); //new float[ow 2];`
`317`	`326`	`float* beta = (float)(buf + param->output_width + param->output_height + param->output_width 2); //new float[oh * 2];`
`318`	`327`
`319`		`- linear_coeffs(in_w, out_w, xofs, alpha);`
`320`		`- linear_coeffs(in_h, out_h, yofs, beta);`
	`328`	`+ int align_corner = param->resize_type == 2? 0 : 1;`
	`329`	`+ linear_coeffs(in_w, out_w, xofs, alpha, align_corner);`
	`330`	`+ linear_coeffs(in_h, out_h, yofs, beta, align_corner);`
`321`	`331`
`322`	`332`	`for (int q = 0; q < channel; ++q)`
`323`	`333`	`{`
`@@ -398,7 +408,7 @@ int ref_interp_uint8(struct tensor* input_tensor, struct tensor* output_tensor,`
`398`	`408`	`}`
`399`	`409`	`}`
`400`	`410`	`}`
`401`		`- else if (param->resize_type == 2)`
	`411`	`+ else if (param->resize_type == 2 \|\| param->resize_type == 4)`
`402`	`412`	`{`
`403`	`413`	`int batch = input_tensor->dims[0];`
`404`	`414`	`int channel = input_tensor->dims[1];`
`@@ -424,8 +434,9 @@ int ref_interp_uint8(struct tensor* input_tensor, struct tensor* output_tensor,`
`424`	`434`	`float* alpha = (float)(buf + param->output_width + param->output_height); //new float[ow 2];`
`425`	`435`	`float* beta = (float)(buf + param->output_width + param->output_height + param->output_width 2); //new float[oh * 2];`
`426`	`436`
`427`		`- linear_coeffs(in_w, out_w, xofs, alpha);`
`428`		`- linear_coeffs(in_h, out_h, yofs, beta);`
	`437`	`+ int align_corner = param->resize_type == 2? 0 : 1;`
	`438`	`+ linear_coeffs(in_w, out_w, xofs, alpha, align_corner);`
	`439`	`+ linear_coeffs(in_h, out_h, yofs, beta, align_corner);`
`429`	`440`
`430`	`441`	`for (int q = 0; q < channel; ++q)`
`431`	`442`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2136,6 +2136,17 @@ int load_resize(ir_graph_t* graph, ir_node_t* node, const onnx::NodeProto& onnx_`
`2136`	`2136`	`interp_param->height_scale = 0;`
`2137`	`2137`	`interp_param->width_scale = 0;`
`2138`	`2138`
	`2139`	`+ int align_corner = 0;`
	`2140`	`+ for (int k = 0; k < onnx_node.attribute_size(); k++)`
	`2141`	`+ {`
	`2142`	`+ const onnx::AttributeProto& attr = onnx_node.attribute(k);`
	`2143`	`+ if (attr.name() == "coordinate_transformation_mode")`
	`2144`	`+ {`
	`2145`	`+ if (attr.s() == "align_corners")`
	`2146`	`+ align_corner = 1;`
	`2147`	`+ }`
	`2148`	`+ }`
	`2149`	`+`
`2139`	`2150`	`if (onnx_node.input_size() == 1)`
`2140`	`2151`	`{`
`2141`	`2152`	`for (int k = 0; k < onnx_node.attribute_size(); k++)`
`@@ -2198,7 +2209,7 @@ int load_resize(ir_graph_t* graph, ir_node_t* node, const onnx::NodeProto& onnx_`
`2198`	`2209`	`}`
`2199`	`2210`	`else if (mode == "bilinear" \|\| mode == "linear")`
`2200`	`2211`	`{`
`2201`		`- interp_param->resize_type = 2;`
	`2212`	`+ interp_param->resize_type = align_corner == 0? 2 : 4;`
`2202`	`2213`	`}`
`2203`	`2214`
`2204`	`2215`	`return 0;`