Fix typo (bolck -> block) (#61684)

co63oc · web-flow · commit 9ffc90e38260 · 2024-02-09T15:07:30.000+08:00
diff --git a/test/legacy_test/test_conv2d_op.py b/test/legacy_test/test_conv2d_op.py
@@ -103,8 +103,8 @@ def _get_padding_with_SAME(input_shape, pool_size, pool_stride):
     )
     out = np.zeros((out_n, out_c, out_h, out_w))
 
-    d_bolck_h = dilation[0] * (f_h - 1) + 1
-    d_bolck_w = dilation[1] * (f_w - 1) + 1
+    d_block_h = dilation[0] * (f_h - 1) + 1
+    d_block_w = dilation[1] * (f_w - 1) + 1
 
     input_pad = np.pad(
         input,
@@ -113,9 +113,9 @@ def _get_padding_with_SAME(input_shape, pool_size, pool_stride):
         constant_values=0,
     )
 
-    filter_dilation = np.zeros((f_n, f_c, d_bolck_h, d_bolck_w))
+    filter_dilation = np.zeros((f_n, f_c, d_block_h, d_block_w))
     filter_dilation[
-        :, :, 0 : d_bolck_h : dilation[0], 0 : d_bolck_w : dilation[1]
+        :, :, 0 : d_block_h : dilation[0], 0 : d_block_w : dilation[1]
     ] = filter
 
     for i in range(out_h):
@@ -124,8 +124,8 @@ def _get_padding_with_SAME(input_shape, pool_size, pool_stride):
                 input_pad_masked = input_pad[
                     :,
                     g * f_c : (g + 1) * f_c,
-                    i * stride[0] : i * stride[0] + d_bolck_h,
-                    j * stride[1] : j * stride[1] + d_bolck_w,
+                    i * stride[0] : i * stride[0] + d_block_h,
+                    j * stride[1] : j * stride[1] + d_block_w,
                 ]
 
                 f_sub = filter_dilation[
diff --git a/test/legacy_test/test_conv2d_transpose_op.py b/test/legacy_test/test_conv2d_transpose_op.py
@@ -82,10 +82,10 @@ def _get_padding_with_SAME(input_shape, kernel_size, kernel_stride):
         pad_h_0, pad_h_1 = pad[0], pad[1]
         pad_w_0, pad_w_1 = pad[2], pad[3]
 
-    d_bolck_h = dilations[0] * (f_h - 1) + 1
-    d_bolck_w = dilations[1] * (f_w - 1) + 1
-    out_h = (in_h - 1) * stride[0] + d_bolck_h
-    out_w = (in_w - 1) * stride[1] + d_bolck_w
+    d_block_h = dilations[0] * (f_h - 1) + 1
+    d_block_w = dilations[1] * (f_w - 1) + 1
+    out_h = (in_h - 1) * stride[0] + d_block_h
+    out_w = (in_w - 1) * stride[1] + d_block_w
     if 'output_size' in attrs:
         output_size = attrs['output_size']
         out_h = output_size[0] + pad_h_0 + pad_h_1
@@ -117,8 +117,8 @@ def _get_padding_with_SAME(input_shape, kernel_size, kernel_stride):
                             ],
                             axis=0,
                         )
-                        i1, i2 = i * stride[0], i * stride[0] + d_bolck_h
-                        j1, j2 = j * stride[1], j * stride[1] + d_bolck_w
+                        i1, i2 = i * stride[0], i * stride[0] + d_block_h
+                        j1, j2 = j * stride[1], j * stride[1] + d_block_w
                         out[
                             n,
                             g * f_out_c + k,
diff --git a/test/legacy_test/test_conv3d_op.py b/test/legacy_test/test_conv3d_op.py
@@ -117,9 +117,9 @@ def _get_padding_with_SAME(input_shape, pool_size, pool_stride):
 
     out = np.zeros((in_n, out_c, out_d, out_h, out_w))
 
-    d_bolck_d = dilation[0] * (f_d - 1) + 1
-    d_bolck_h = dilation[1] * (f_h - 1) + 1
-    d_bolck_w = dilation[2] * (f_w - 1) + 1
+    d_block_d = dilation[0] * (f_d - 1) + 1
+    d_block_h = dilation[1] * (f_h - 1) + 1
+    d_block_w = dilation[2] * (f_w - 1) + 1
 
     input_pad = np.pad(
         input,
@@ -134,13 +134,13 @@ def _get_padding_with_SAME(input_shape, pool_size, pool_stride):
         constant_values=0,
     )
 
-    filter_dilation = np.zeros((f_n, f_c, d_bolck_d, d_bolck_h, d_bolck_w))
+    filter_dilation = np.zeros((f_n, f_c, d_block_d, d_block_h, d_block_w))
     filter_dilation[
         :,
         :,
-        0 : d_bolck_d : dilation[0],
-        0 : d_bolck_h : dilation[1],
-        0 : d_bolck_w : dilation[2],
+        0 : d_block_d : dilation[0],
+        0 : d_block_h : dilation[1],
+        0 : d_block_w : dilation[2],
     ] = filter
 
     for d in range(out_d):
@@ -150,9 +150,9 @@ def _get_padding_with_SAME(input_shape, pool_size, pool_stride):
                     input_pad_masked = input_pad[
                         :,
                         g * f_c : (g + 1) * f_c,
-                        d * stride[0] : d * stride[0] + d_bolck_d,
-                        i * stride[1] : i * stride[1] + d_bolck_h,
-                        j * stride[2] : j * stride[2] + d_bolck_w,
+                        d * stride[0] : d * stride[0] + d_block_d,
+                        i * stride[1] : i * stride[1] + d_block_h,
+                        j * stride[2] : j * stride[2] + d_block_w,
                     ]
 
                     f_sub = filter_dilation[
diff --git a/test/legacy_test/test_conv3d_transpose_op.py b/test/legacy_test/test_conv3d_transpose_op.py
@@ -92,12 +92,12 @@ def _get_padding_with_SAME(input_shape, kernel_size, kernel_stride):
         pad_h_0, pad_h_1 = pad[2], pad[3]
         pad_w_0, pad_w_1 = pad[4], pad[5]
 
-    d_bolck_d = dilations[0] * (f_d - 1) + 1
-    d_bolck_h = dilations[1] * (f_h - 1) + 1
-    d_bolck_w = dilations[2] * (f_w - 1) + 1
-    out_d = (in_d - 1) * stride[0] + d_bolck_d
-    out_h = (in_h - 1) * stride[1] + d_bolck_h
-    out_w = (in_w - 1) * stride[2] + d_bolck_w
+    d_block_d = dilations[0] * (f_d - 1) + 1
+    d_block_h = dilations[1] * (f_h - 1) + 1
+    d_block_w = dilations[2] * (f_w - 1) + 1
+    out_d = (in_d - 1) * stride[0] + d_block_d
+    out_h = (in_h - 1) * stride[1] + d_block_h
+    out_w = (in_w - 1) * stride[2] + d_block_w
     out = np.zeros((in_n, out_c, out_d, out_h, out_w))
 
     for n in range(in_n):
@@ -125,9 +125,9 @@ def _get_padding_with_SAME(input_shape, kernel_size, kernel_stride):
                                 ],
                                 axis=0,
                             )
-                            d1, d2 = d * stride[0], d * stride[0] + d_bolck_d
-                            i1, i2 = i * stride[1], i * stride[1] + d_bolck_h
-                            j1, j2 = j * stride[2], j * stride[2] + d_bolck_w
+                            d1, d2 = d * stride[0], d * stride[0] + d_block_d
+                            i1, i2 = i * stride[1], i * stride[1] + d_block_h
+                            j1, j2 = j * stride[2], j * stride[2] + d_block_w
                             out[
                                 n,
                                 g * f_out_c + k,
diff --git a/test/xpu/test_conv2d_op_xpu.py b/test/xpu/test_conv2d_op_xpu.py
@@ -106,8 +106,8 @@ def _get_padding_with_SAME(input_shape, pool_size, pool_stride):
     )
     out = np.zeros((out_n, out_c, out_h, out_w))
 
-    d_bolck_h = dilation[0] * (f_h - 1) + 1
-    d_bolck_w = dilation[1] * (f_w - 1) + 1
+    d_block_h = dilation[0] * (f_h - 1) + 1
+    d_block_w = dilation[1] * (f_w - 1) + 1
 
     input_pad = np.pad(
         input,
@@ -116,9 +116,9 @@ def _get_padding_with_SAME(input_shape, pool_size, pool_stride):
         constant_values=0,
     )
 
-    filter_dilation = np.zeros((f_n, f_c, d_bolck_h, d_bolck_w))
+    filter_dilation = np.zeros((f_n, f_c, d_block_h, d_block_w))
     filter_dilation[
-        :, :, 0 : d_bolck_h : dilation[0], 0 : d_bolck_w : dilation[1]
+        :, :, 0 : d_block_h : dilation[0], 0 : d_block_w : dilation[1]
     ] = filter
 
     for i in range(out_h):
@@ -127,8 +127,8 @@ def _get_padding_with_SAME(input_shape, pool_size, pool_stride):
                 input_pad_masked = input_pad[
                     :,
                     g * f_c : (g + 1) * f_c,
-                    i * stride[0] : i * stride[0] + d_bolck_h,
-                    j * stride[1] : j * stride[1] + d_bolck_w,
+                    i * stride[0] : i * stride[0] + d_block_h,
+                    j * stride[1] : j * stride[1] + d_block_w,
                 ]
 
                 f_sub = filter_dilation[
diff --git a/test/xpu/test_conv2d_transpose_op_xpu.py b/test/xpu/test_conv2d_transpose_op_xpu.py
@@ -80,10 +80,10 @@ def _get_padding_with_SAME(input_shape, kernel_size, kernel_stride):
         pad_h_0, pad_h_1 = pad[0], pad[1]
         pad_w_0, pad_w_1 = pad[2], pad[3]
 
-    d_bolck_h = dilations[0] * (f_h - 1) + 1
-    d_bolck_w = dilations[1] * (f_w - 1) + 1
-    out_h = (in_h - 1) * stride[0] + d_bolck_h
-    out_w = (in_w - 1) * stride[1] + d_bolck_w
+    d_block_h = dilations[0] * (f_h - 1) + 1
+    d_block_w = dilations[1] * (f_w - 1) + 1
+    out_h = (in_h - 1) * stride[0] + d_block_h
+    out_w = (in_w - 1) * stride[1] + d_block_w
     if 'output_size' in attrs:
         output_size = attrs['output_size']
         out_h = output_size[0] + pad_h_0 + pad_h_1
@@ -115,8 +115,8 @@ def _get_padding_with_SAME(input_shape, kernel_size, kernel_stride):
                             ],
                             axis=0,
                         )
-                        i1, i2 = i * stride[0], i * stride[0] + d_bolck_h
-                        j1, j2 = j * stride[1], j * stride[1] + d_bolck_w
+                        i1, i2 = i * stride[0], i * stride[0] + d_block_h
+                        j1, j2 = j * stride[1], j * stride[1] + d_block_w
                         out[
                             n,
                             g * f_out_c + k,
diff --git a/test/xpu/test_conv3d_op_xpu.py b/test/xpu/test_conv3d_op_xpu.py
@@ -111,9 +111,9 @@ def _get_padding_with_SAME(input_shape, pool_size, pool_stride):
 
     out = np.zeros((in_n, out_c, out_d, out_h, out_w))
 
-    d_bolck_d = dilation[0] * (f_d - 1) + 1
-    d_bolck_h = dilation[1] * (f_h - 1) + 1
-    d_bolck_w = dilation[2] * (f_w - 1) + 1
+    d_block_d = dilation[0] * (f_d - 1) + 1
+    d_block_h = dilation[1] * (f_h - 1) + 1
+    d_block_w = dilation[2] * (f_w - 1) + 1
 
     input_pad = np.pad(
         input,
@@ -128,13 +128,13 @@ def _get_padding_with_SAME(input_shape, pool_size, pool_stride):
         constant_values=0,
     )
 
-    filter_dilation = np.zeros((f_n, f_c, d_bolck_d, d_bolck_h, d_bolck_w))
+    filter_dilation = np.zeros((f_n, f_c, d_block_d, d_block_h, d_block_w))
     filter_dilation[
         :,
         :,
-        0 : d_bolck_d : dilation[0],
-        0 : d_bolck_h : dilation[1],
-        0 : d_bolck_w : dilation[2],
+        0 : d_block_d : dilation[0],
+        0 : d_block_h : dilation[1],
+        0 : d_block_w : dilation[2],
     ] = filter
 
     for d in range(out_d):
@@ -144,9 +144,9 @@ def _get_padding_with_SAME(input_shape, pool_size, pool_stride):
                     input_pad_masked = input_pad[
                         :,
                         g * f_c : (g + 1) * f_c,
-                        d * stride[0] : d * stride[0] + d_bolck_d,
-                        i * stride[1] : i * stride[1] + d_bolck_h,
-                        j * stride[2] : j * stride[2] + d_bolck_w,
+                        d * stride[0] : d * stride[0] + d_block_d,
+                        i * stride[1] : i * stride[1] + d_block_h,
+                        j * stride[2] : j * stride[2] + d_block_w,
                     ]
 
                     f_sub = filter_dilation[
diff --git a/test/xpu/test_depthwise_conv2d_transpose_op_xpu.py b/test/xpu/test_depthwise_conv2d_transpose_op_xpu.py
@@ -80,10 +80,10 @@ def _get_padding_with_SAME(input_shape, kernel_size, kernel_stride):
         pad_h_0, pad_h_1 = pad[0], pad[1]
         pad_w_0, pad_w_1 = pad[2], pad[3]
 
-    d_bolck_h = dilations[0] * (f_h - 1) + 1
-    d_bolck_w = dilations[1] * (f_w - 1) + 1
-    out_h = (in_h - 1) * stride[0] + d_bolck_h
-    out_w = (in_w - 1) * stride[1] + d_bolck_w
+    d_block_h = dilations[0] * (f_h - 1) + 1
+    d_block_w = dilations[1] * (f_w - 1) + 1
+    out_h = (in_h - 1) * stride[0] + d_block_h
+    out_w = (in_w - 1) * stride[1] + d_block_w
     if 'output_size' in attrs:
         output_size = attrs['output_size']
         out_h = output_size[0] + pad_h_0 + pad_h_1
@@ -115,8 +115,8 @@ def _get_padding_with_SAME(input_shape, kernel_size, kernel_stride):
                             ],
                             axis=0,
                         )
-                        i1, i2 = i * stride[0], i * stride[0] + d_bolck_h
-                        j1, j2 = j * stride[1], j * stride[1] + d_bolck_w
+                        i1, i2 = i * stride[0], i * stride[0] + d_block_h
+                        j1, j2 = j * stride[1], j * stride[1] + d_block_w
                         out[
                             n,
                             g * f_out_c + k,
