Huawei_Technology
/
MindSpore-AKG
Not watched
1
0
Fork 0
Code
Releases 1 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
MindSpore-AKG/python/akg/ops/nn/conv.py

875 lines
39 kB
Raw Permalink Blame History 

  1. #!/usr/bin/env python3

  2. # coding: utf-8

  3. # Copyright 2019 Huawei Technologies Co., Ltd

  4. #

  5. # Licensed under the Apache License, Version 2.0 (the "License");

  6. # you may not use this file except in compliance with the License.

  7. # You may obtain a copy of the License at

  8. #

  9. # http://www.apache.org/licenses/LICENSE-2.0

  10. #

  11. # Unless required by applicable law or agreed to in writing, software

  12. # distributed under the License is distributed on an "AS IS" BASIS,

  13. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  14. # See the License for the specific language governing permissions and

  15. # limitations under the License.

  16. 

  17. """operator dsl function: conv"""

  18. import akg.tvm

  19. import akg

  20. import akg.lang.cce

  21. from akg import dim

  22. 

  23. from akg.ops.math import cast

  24. from akg.utils import validation_check as vc_util

  25. from akg.utils.format_transform import get_shape

  26. from akg.utils.dynamic_shape import set_poly_upper_bound_for_tensor

  27. 

  28. k_h_fake = 11

  29. k_w_fake = 31

  30. p_top_fake = 9

  31. p_bottom_fake = 8

  32. p_left_fake = 23

  33. p_right_fake = 21

  34. s_h_fake = 7

  35. s_w_fake = 17

  36. c1_cut_fake = 67

  37. tile_out_h_fake = 47

  38. tile_out_w_fake = 37

  39. m_cut_fake = 53 * 16

  40. k_cut_fake = 59 * 16

  41. n_cut_fake = 61 * 16

  42. 

  43. conv_set_dim_map = {

  44.     str(((1, 1024, 14, 14), (2048, 1024, 1, 1), (0, 0, 0, 0), (2, 2), (1, 1), True)):

  45.         ([14, 2048, 64, 96, 128], {"bypass": 1}),

  46.     str(((1, 1024, 14, 14), (256, 1024, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), True)):

  47.         ([14, 256, 208, 64, 112], {"bypass": 1}),

  48.     str(((1, 1024, 14, 14), (512, 1024, 1, 1), (0, 0, 0, 0), (2, 2), (1, 1), True)):

  49.         ([14, 512, 49, 32, 512], {"bypass": 1}),

  50.     str(((1, 128, 28, 28), (128, 128, 3, 3), (1, 1, 1, 1), (1, 1), (1, 1), False)):

  51.         ([28, 128, 400, 32, 128], {"bypass": 1}),

  52.     str(((1, 128, 28, 28), (128, 128, 3, 3), (1, 1, 1, 1), (1, 1), (2, 2), True)):

  53.         ([28, 128, 400, 32, 128], {"bypass": 1}),

  54.     str(((1, 128, 28, 28), (512, 128, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), True)):

  55.         ([28, 512, 784, 16, 32], {"bypass": 1}),

  56.     str(((1, 128, 28, 32), (128, 128, 3, 3), (1, 1, 1, 1), (1, 1), (1, 1), True)):

  57.         ([28, 128, 16, 72 * 16, 16], {"bypass": 1}),

  58.     str(((1, 128, 34, 34), (128, 128, 3, 3), (1, 1, 1, 1), (1, 1), (2, 2), True)):

  59.         ([36, 128, 64, 32, 64], {"bypass": 1}),

  60.     str(((1, 128, 36, 36), (128, 128, 3, 3), (0, 0, 0, 0), (1, 1), (2, 2), False)):

  61.         ([36, 128, 64, 32, 64], {"bypass": 1}),

  62.     str(((1, 16, 16, 16), (64, 16, 3, 3), (1, 1, 1, 1), (1, 1), (1, 1), True)):

  63.         [16, 4 * 16, 16 * 16, 3 * 16, 4 * 16, 16 + 2],

  64.     str(((1, 2048, 7, 7), (512, 2048, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), True)):

  65.         ([7, 512, 49, 32, 512], {"bypass": 1}),

  66.     str(((1, 256, 14, 14), (1024, 256, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), True)):

  67.         ([14, 944, 112, 32, 240], {"bypass": 1}),

  68.     str(((1, 256, 14, 14), (256, 256, 3, 3), (1, 1, 1, 1), (1, 1), (1, 1), False)):

  69.         ([14, 256, 196, 64, 256], {"bypass": 1}),

  70.     str(((1, 256, 14, 14), (256, 256, 3, 3), (1, 1, 1, 1), (1, 1), (2, 2), True)):

  71.         ([14, 256, 196, 64, 256], {"bypass": 1}),

  72.     str(((1, 256, 56, 56), (128, 256, 1, 1), (0, 0, 0, 0), (2, 2), (1, 1), True)):

  73.         ([7, 128, 252, 64, 128], {"bypass": 1}),

  74.     str(((1, 256, 56, 56), (512, 256, 1, 1), (0, 0, 0, 0), (2, 2), (1, 1), True)):

  75.         ([7, 512, 196, 64, 256], {"bypass": 1}),

  76.     str(((1, 256, 56, 56), (64, 256, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), True)):

  77.         ([16, 64, 280, 16, 64], {"bypass": 1}),

  78.     str(((1, 3, 224, 224), (64, 3, 7, 7), (2, 3, 2, 3), (2, 2), (1, 1), True)):

  79.         ([117, 64, 448, 32, 64], {"bypass": 1}),

  80.     str(((1, 3, 224, 224), (64, 3, 7, 7), (3, 3, 3, 3), (2, 2), (1, 1), True)):

  81.         ([65, 64, 448, 32, 64], {"bypass": 1}),

  82.     str(((1, 512, 14, 14), (512, 512, 3, 3), (1, 1, 1, 1), (2, 2), (1, 1), False)):

  83.         ([14, 512, 64, 48, 128, 16], {"bypass": 1}),

  84.     str(((1, 512, 28, 28), (1024, 512, 1, 1), (0, 0, 0, 0), (2, 2), (1, 1), True)):

  85.         ([13, 1024, 112, 32, 512], {"bypass": 1}),

  86.     str(((1, 512, 28, 28), (128, 512, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), True)):

  87.         ([14, 128, 448, 16, 64], {"bypass": 1}),

  88.     str(((1, 512, 28, 28), (256, 512, 1, 1), (0, 0, 0, 0), (2, 2), (1, 1), True)):

  89.         ([11, 256, 98, 64, 256], {"bypass": 1}),

  90.     str(((1, 512, 7, 7), (2048, 512, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), True)):

  91.         ([7, 2048, 49, 16, 512], {"bypass": 1}),

  92.     str(((1, 512, 7, 7), (512, 512, 3, 3), (1, 1, 1, 1), (1, 1), (1, 1), False)):

  93.         ([7, 512, 49, 32, 512], {"bypass": 1}),

  94.     str(((1, 512, 7, 7), (512, 512, 3, 3), (1, 1, 1, 1), (1, 1), (2, 2), True)):

  95.         ([7, 512, 49, 32, 512], {"bypass": 1}),

  96.     str(((1, 64, 112, 112), (64, 64, 1, 1), (0, 0, 0, 0), (2, 2), (1, 1), False)):

  97.         ([56, 64, 784, 16, 32], {"bypass": 1}),

  98.     str(((1, 64, 56, 56), (256, 64, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), True)):

  99.         ([56, 256, 784, 16, 32], {"bypass": 1}),

  100.     str(((1, 64, 56, 56), (64, 64, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), True)):

  101.         ([56, 64, 784, 16, 32], {"bypass": 1}),

  102.     str(((1, 64, 56, 56), (64, 64, 3, 3), (1, 1, 1, 1), (1, 1), (1, 1), False)):

  103.         ([56, 64, 336, 16, 64], {"bypass": 1}),

  104.     str(((2, 1024, 48, 72), (2048, 1024, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  105.         ([5, 128, 288, 16, 112, 72], {"bypass": 0}),

  106.     str(((2, 1024, 48, 72), (256, 1024, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  107.         ([4, 128, 256, 96, 64, 72], {"bypass": 0}),

  108.     str(((2, 1024, 48, 72), (512, 1024, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  109.         ([3, 512, 160, 160, 96, 72], {"bypass": 1}),

  110.     str(((2, 128, 192, 288), (256, 128, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  111.         ([3, 128, 288, 48, 48, 288], {"bypass": 0}),

  112.     str(((2, 128, 192, 288), (64, 128, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  113.         ([3, 64, 176, 80, 64, 288], {"bypass": 1}),

  114.     str(((2, 128, 48, 72), (512, 128, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  115.         ([8, 256, 256, 16, 48, 72], {"bypass": 0}),

  116.     str(((2, 128, 96, 144), (128, 128, 3, 3), (1, 1, 1, 1), (2, 2), (1, 1), False)):

  117.         ([17, 16, 256, 96, 16, 145], {"bypass": 0}),

  118.     str(((2, 128, 96, 144), (128, 128, 3, 3), (2, 2, 2, 2), (1, 1), (1, 1), False)):

  119.         ([17, 32, 320, 48, 32, 148], {"bypass": 0}),

  120.     str(((2, 128, 96, 144), (512, 128, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  121.         ([6, 256, 160, 16, 192, 144], {"bypass": 0}),

  122.     str(((2, 1280, 48, 72), (256, 1280, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  123.         ([4, 64, 48, 160, 64, 72], {"bypass": 0}),

  124.     str(((2, 16, 768, 1152), (64, 16, 3, 3), (1, 1, 1, 1), (2, 2), (1, 1), False)):

  125.         ([25, 16, 256, 48, 16, 1153], {"bypass": 0}),

  126.     str(((2, 2048, 1, 1), (256, 2048, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  127.         ([1, 64, 16, 176, 64, 1], {"bypass": 0}),

  128.     str(((2, 2048, 48, 72), (256, 2048, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  129.         ([3, 256, 48, 432, 64, 72], {"bypass": 1}),

  130.     str(((2, 2048, 48, 72), (512, 2048, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  131.         ([2, 512, 144, 64, 80, 72], {"bypass": 1}),

  132.     str(((2, 256, 192, 288), (64, 256, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  133.         ([3, 64, 256, 128, 64, 288], {"bypass": 0}),

  134.     str(((2, 256, 48, 72), (1024, 256, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  135.         ([6, 64, 144, 176, 16, 72], {"bypass": 0}),

  136.     str(((2, 256, 48, 72), (256, 256, 3, 3), (2, 2, 2, 2), (1, 1), (1, 1), False)):

  137.         ([19, 16, 240, 96, 16, 76], {"bypass": 0}),

  138.     str(((2, 256, 48, 72), (3, 256, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  139.         ([6, 16, 16, 208, 16, 72], {"bypass": 0}),

  140.     str(((2, 256, 96, 144), (128, 256, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  141.         ([96, 128, 128, 64, 64, 16], {"bypass": 0}),

  142.     str(((2, 256, 96, 144), (512, 256, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  143.         ([8, 512, 336, 48, 112, 144], {"bypass": 0}),

  144.     str(((2, 512, 48, 72), (1024, 512, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  145.         ([4, 256, 112, 32, 176, 72], {"bypass": 0}),

  146.     str(((2, 512, 48, 72), (2048, 512, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  147.         ([4, 64, 288, 48, 32, 72], {"bypass": 0}),

  148.     str(((2, 512, 48, 72), (256, 512, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  149.         ([4, 64, 96, 16, 32, 72], {"bypass": 0}),

  150.     str(((2, 512, 96, 144), (128, 512, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  151.         ([4, 128, 272, 32, 96, 144], {"bypass": 0}),

  152.     str(((2, 64, 192, 288), (256, 64, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  153.         ([6, 64, 192, 16, 64, 288], {"bypass": 0}),

  154.     str(((2, 64, 192, 288), (64, 64, 3, 3), (1, 1, 1, 1), (2, 2), (1, 1), False)):

  155.         ([193, 16, 352, 80, 16, 33], {"bypass": 0}),

  156.     str(((2, 64, 192, 288), (64, 64, 3, 3), (2, 2, 2, 2), (1, 1), (1, 1), False)):

  157.         ([9, 16, 1968, 16, 16, 292], {"bypass": 0}),

  158.     str(((2, 64, 384, 576), (128, 64, 3, 3), (2, 2, 2, 2), (1, 1), (1, 1), False)):

  159.         ([5, 16, 1600, 16, 16, 580], {"bypass": 0}),

  160.     str(((2, 64, 384, 576), (64, 64, 3, 3), (2, 2, 2, 2), (1, 1), (1, 1), False)):

  161.         ([388, 32, 448, 32, 32, 18], {"bypass": 0}),

  162.     str(((2, 64, 96, 144), (256, 64, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  163.         ([96, 256, 224, 32, 96, 16], {"bypass": 1}),

  164.     str(((32, 1024, 14, 14), (2048, 1024, 1, 1), (0, 0, 0, 0), (2, 2), (1, 1), False)):

  165.         ([13, 2048, 64, 48, 336, 13], {"bypass": 1}),

  166.     str(((32, 1024, 14, 14), (256, 1024, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  167.         ([14, 256, 112, 112, 128, 14], {"bypass": 1}),

  168.     str(((32, 1024, 14, 14), (512, 1024, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  169.         ([14, 272, 160, 32, 176, 14], {"bypass": 0}),

  170.     str(((32, 1024, 14, 14), (512, 1024, 1, 1), (0, 0, 0, 0), (2, 2), (1, 1), False)):

  171.         ([13, 512, 64, 80, 112, 13], {"bypass": 1}),

  172.     str(((32, 128, 28, 28), (128, 128, 3, 3), (1, 1, 1, 1), (1, 1), (1, 1), False)):

  173.         ([18, 128, 336, 32, 80, 30], {"bypass": 0}),

  174.     str(((32, 128, 28, 28), (512, 128, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  175.         ([4, 288, 112, 96, 272, 28], {"bypass": 0}),

  176.     str(((32, 128, 56, 56), (128, 128, 3, 3), (0, 1, 0, 1), (2, 2), (1, 1), False)):

  177.         ([57, 128, 288, 48, 128, 41], {"bypass": 0}),

  178.     str(((32, 16, 33, 33), (64, 16, 3, 3), (0, 0, 0, 0), (2, 2), (1, 1), False)):

  179.         [128, 128, 64, 128, 64],

  180.     str(((32, 16, 34, 34), (64, 16, 3, 3), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  181.         [128, 128, 64, 128, 64],

  182.     str(((32, 2048, 7, 7), (512, 2048, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  183.         ([7, 512, 64, 80, 176, 7], {"bypass": 1}),

  184.     str(((32, 256, 14, 14), (1024, 256, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  185.         ([14, 352, 176, 128, 192, 14], {"bypass": 0}),

  186.     str(((32, 256, 14, 14), (256, 256, 3, 3), (1, 1, 1, 1), (1, 1), (1, 1), False)):

  187.         ([14, 192, 160, 96, 160, 16], {"bypass": 0}),

  188.     str(((32, 256, 28, 28), (256, 256, 3, 3), (0, 1, 0, 1), (2, 2), (1, 1), False)):

  189.         ([17, 256, 112, 112, 160, 29], {"bypass": 1}),

  190.     str(((32, 256, 56, 56), (128, 256, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  191.         ([10, 128, 336, 32, 128, 56], {"bypass": 0}),

  192.     str(((32, 256, 56, 56), (128, 256, 1, 1), (0, 0, 0, 0), (2, 2), (1, 1), False)):

  193.         ([15, 128, 16, 256, 80, 55], {"bypass": 1}),

  194.     str(((32, 256, 56, 56), (512, 256, 1, 1), (0, 0, 0, 0), (2, 2), (1, 1), False)):

  195.         ([13, 384, 32, 32, 384, 55], {"bypass": 0}),

  196.     str(((32, 256, 56, 56), (64, 256, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  197.         ([12, 64, 336, 16, 64, 56], {"bypass": 0}),

  198.     str(((32, 3, 224, 224), (64, 3, 7, 7), (2, 3, 2, 3), (2, 2), (1, 1), False)):

  199.         ([17, 64, 336, 48, 64, 229], {"bypass": 0}),

  200.     str(((32, 3, 224, 224), (64, 3, 7, 7), (3, 3, 3, 3), (2, 2), (1, 1), False)):

  201.         ([149, 64, 96, 35, 64, 117], {"bypass": 0}),

  202.     str(((32, 512, 14, 14), (512, 512, 3, 3), (0, 1, 0, 1), (2, 2), (1, 1), False)):

  203.         ([15, 512, 64, 32, 368, 15], {"bypass": 1}),

  204.     str(((32, 512, 28, 28), (1024, 512, 1, 1), (0, 0, 0, 0), (2, 2), (1, 1), False)):

  205.         ([27, 1024, 160, 112, 96, 27], {"bypass": 1}),

  206.     str(((32, 512, 28, 28), (128, 512, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  207.         ([6, 128, 160, 16, 128, 28], {"bypass": 0}),

  208.     str(((32, 512, 28, 28), (256, 512, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  209.         ([28, 128, 144, 160, 128, 28], {"bypass": 0}),

  210.     str(((32, 512, 28, 28), (256, 512, 1, 1), (0, 0, 0, 0), (2, 2), (1, 1), False)):

  211.         ([27, 256, 160, 144, 32, 27], {"bypass": 1}),

  212.     str(((32, 512, 7, 7), (2048, 512, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  213.         ([7, 2048, 64, 48, 336, 7], {"bypass": 1}),

  214.     str(((32, 512, 7, 7), (512, 512, 3, 3), (1, 1, 1, 1), (1, 1), (1, 1), False)):

  215.         ([9, 512, 64, 256, 64, 9], {"bypass": 1}),

  216.     str(((32, 64, 56, 56), (256, 64, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  217.         ([42, 176, 224, 48, 96, 56], {"bypass": 0}),

  218.     str(((32, 64, 56, 56), (64, 64, 1, 1), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  219.         ([12, 64, 32, 64, 64, 56], {"bypass": 1}),

  220.     str(((32, 64, 56, 56), (64, 64, 3, 3), (1, 1, 1, 1), (1, 1), (1, 1), False)):

  221.         ([40, 64, 1120, 16, 48, 58], {"bypass": 0}),

  222.     str(((32, 96, 28, 28), (256, 96, 5, 5), (2, 2, 2, 2), (1, 1), (1, 1), False)):

  223.         ([28, 64, 112, 160, 32, 32], {"bypass": 0}),

  224.     str(((8, 512, 26, 38), (512, 512, 3, 3), (0, 0, 0, 0), (1, 1), (1, 1), False)):

  225.         ([26, 512, 128, 96, 80, 11], {"bypass": 1}),

  226.     str(((32, 3, 227, 227), (96, 3, 11, 11), (0, 0, 0, 0), (4, 4), (1, 1), False)):

  227.         ([63, 96, 208, 32, 96, 227], {"bypass": 0}),

  228.     str(((32, 96, 27, 27), (256, 96, 5, 5), (2, 2, 2, 2), (1, 1), (1, 1), False)):

  229.         ([21, 160, 352, 32, 96, 31], {"bypass": 0})

  230. }

  231. 

  232. 

  233. def conv_set_dim_func(fmap_shape, filter_shape, pad, stride, dilation,

  234.                       use_bias=False, block_size=16, attrs=None, setdim_map=None):

  235.     """set dim info in attrs by conv_set_dim_map."""

  236.     if isinstance(stride, int):

  237.         stride = [stride] * 2

  238.     elif isinstance(stride, (list, tuple)) and len(stride) == 1:

  239.         stride = list(stride) * 2

  240.     elif isinstance(stride, (list, tuple)) and len(stride) == 2:

  241.         pass

  242.     else:

  243.         raise IndexError("stride para illegal !!!")

  244. 

  245.     if isinstance(pad, int):

  246.         pad = [pad] * 4

  247.     elif isinstance(pad, (list, tuple)) and len(pad) == 1:

  248.         pad = list(pad) * 4

  249.     elif isinstance(pad, (list, tuple)) and len(pad) == 4:

  250.         pass

  251.     else:

  252.         raise IndexError("pad para illegal !!!")

  253. 

  254.     if isinstance(dilation, int):

  255.         dilation = [dilation] * 2

  256.     elif isinstance(dilation, (list, tuple)) and len(dilation) == 1:

  257.         dilation = list(dilation) * 2

  258.     elif isinstance(dilation, (list, tuple)) and len(dilation) == 2:

  259.         pass

  260.     else:

  261.         raise IndexError("dilation para illegal !!!")

  262. 

  263.     key = []

  264. 

  265.     key.append(tuple(fmap_shape))

  266.     key.append(tuple(filter_shape))

  267.     key.append(tuple(pad))

  268.     key.append(tuple(stride))

  269.     key.append(tuple(dilation))

  270.     key.append(use_bias)

  271. 

  272.     hash_key = str(tuple(key))

  273. 

  274.     # input shape (NCHW -> NC1HWC0)

  275.     in_n, in_c, in_h, in_w = fmap_shape

  276.     in_c = (in_c + block_size - 1) // block_size * block_size

  277. 

  278.     # kernel shape (NCHW -> NC1HWC0 -> Fractal)

  279.     k_n, k_c, k_h, k_w = filter_shape

  280.     k_c = (k_c + block_size - 1) // block_size * block_size

  281.     k_n = (k_n + block_size - 1) // block_size * block_size

  282. 

  283.     # padding(padding_top, padding_bottom, padding_left, padding_right)

  284.     padding = (pad[0], pad[1], pad[2], pad[3])

  285.     p_top, p_bottom, p_left, p_right = padding

  286. 

  287.     # stride (stride_h, stride_w)

  288.     s_h, s_w = stride

  289. 

  290.     # dilation (dilation_h, dilation_w)

  291.     d_h, d_w = dilation

  292. 

  293.     k_w_d = (k_w - 1) * d_w + 1

  294.     out_w = (in_w + p_left + p_right - k_w_d) // (s_w) + 1

  295. 

  296.     all_dynamic = 0      # kh kw pad stride

  297.     partial_dynamic = 0  # fn fc1 fh fw wN wC

  298.     if attrs is None:

  299.         attrs = {}

  300.     if attrs.get("dynamic"):

  301.         all_dynamic = 1

  302.     if attrs.get("partial_dynamic"):

  303.         partial_dynamic = 1

  304.     dynamic = partial_dynamic or all_dynamic

  305. 

  306.     bypass_list = [0, 1]

  307.     bypass = 0 if dynamic else 1

  308.     dynamic_tiling = 1 if attrs.get("dynamic") else 0  # tile size is a parameter

  309.     use_autotiling = 1 if dynamic and not dynamic_tiling else 0

  310. 

  311.     dynamic_ci_c1 = 128

  312. 

  313.     if attrs is not None and "conv_tile" in attrs and len(attrs["conv_tile"]) >= 5:

  314.         use_autotiling = 0

  315.         tiles = attrs["conv_tile"]

  316.         tile_hh = attrs["conv_tile"][0]

  317.         tile_coco = attrs["conv_tile"][1]

  318.         tile_mm = attrs["conv_tile"][2]

  319.         tile_kk = attrs["conv_tile"][3]

  320.         tile_nn = attrs["conv_tile"][4]

  321.         if len(attrs["conv_tile"]) > 5:

  322.             tile_ww = attrs["conv_tile"][5]

  323.             if dynamic and not use_autotiling and len(attrs["conv_tile"]) == 7:

  324.                 dynamic_ci_c1 = attrs["conv_tile"][6]

  325.         else:

  326.             tile_ww = (out_w - 1) * s_w + k_w_d

  327.         if "bypass" in attrs:

  328.             bypass = attrs["bypass"]

  329.     elif hash_key in setdim_map:

  330.         configs = setdim_map[hash_key]

  331.         if isinstance(configs, tuple):

  332.             tiles = configs[0]

  333.             if "bypass" in configs[1]:

  334.                 bypass = configs[1]["bypass"]

  335.         else:

  336.             tiles = configs

  337.         if len(tiles) > 5:

  338.             tile_hh, tile_coco, tile_mm, tile_kk, tile_nn, tile_ww = tiles

  339.         else:

  340.             tile_hh, tile_coco, tile_mm, tile_kk, tile_nn = tiles

  341.             tile_ww = (out_w - 1) * s_w + k_w_d

  342.     else:

  343.         win_cut_h = 1

  344.         k_h_d = (k_h - 1) * d_h + 1

  345.         win_h = (in_h + p_top + p_bottom - k_h_d) // (s_h) + 1

  346.         if not dynamic:

  347.             while win_cut_h <= win_h:

  348.                 if (((win_h + win_cut_h - 1) // win_cut_h - 1) * win_cut_h - 1) * s_h + k_h_d <= in_h + p_top:

  349.                     break

  350.                 win_cut_h += 1

  351.         tile_hh = (win_cut_h - 1) * s_h + k_h_d

  352.         tile_ww = (out_w - 1) * s_w + k_w_d

  353.         tile_coco = 16

  354.         tile_mm = 16

  355.         tile_kk = 16

  356.         tile_nn = 16

  357.         tiles = [tile_hh, tile_coco, tile_mm, tile_kk, tile_nn, tile_ww]

  358.     if bypass not in bypass_list:

  359.         raise ValueError("conv_cce ony supports %s while bypass is %d" % (",".join(str(bypass_list)), bypass))

  360. 

  361.     if tile_hh == in_h:

  362.         tile_hh += p_top + p_bottom

  363.     tile_coco = (tile_coco + block_size - 1) // block_size * block_size

  364.     tile_mm = (tile_mm + block_size - 1) // block_size * block_size

  365.     tile_kk = (tile_kk + block_size - 1) // block_size * block_size

  366.     tile_nn = (tile_nn + block_size - 1) // block_size * block_size

  367. 

  368.     input_shape_nc1hwc0 = (in_n, in_c // block_size, in_h, in_w, block_size)

  369.     in_n, in_c1, in_h, in_w, _ = input_shape_nc1hwc0

  370. 

  371.     kernel_shape_nc1hwc0 = (k_n, k_c // block_size, k_h, k_w, block_size)

  372.     k_n, _, k_h, k_w, _ = kernel_shape_nc1hwc0

  373. 

  374.     k_h_d = (k_h - 1) * d_h + 1

  375.     k_w_d = (k_w - 1) * d_w + 1

  376.     out_h = (in_h + p_top + p_bottom - k_h_d) // (s_h) + 1

  377.     tile_out_h = (tile_hh - k_h_d) // s_h + 1

  378.     out_w = (in_w + p_left + p_right - k_w_d) // (s_w) + 1

  379.     tile_out_w = (tile_ww - k_w_d) // s_w + 1

  380. 

  381.     out_shape_nc1hwc0 = (in_n, k_n // block_size, out_h, out_w, block_size)

  382.     out_n, out_c1, out_h, out_w, out_c0 = out_shape_nc1hwc0

  383. 

  384.     if tile_coco > 0:

  385.         c1_cut = tile_coco // block_size

  386.     else:

  387.         c1_cut = out_c1

  388. 

  389.     # set dim

  390.     def gen_static_dim():

  391.         info = dim.Dim()

  392.         if out_n > 1:

  393.             info.setdim(index=0, axis=0, tilel1=1, tilel0=0)  # n

  394.         if out_c1 > 1:

  395.             info.setdim(index=0, axis=0, tilel1=c1_cut, tilel0=0)  # c1

  396.         if out_h > 1:

  397.             info.setdim(index=0, axis="H", tilel1=tile_out_h, tilel0=0)  # h

  398.         if out_w > 1:

  399.             info.setdim(index=0, axis="W", tilel1=tile_out_w, tilel0=0)  # w

  400.         if out_c0 > 1:

  401.             info.setdim(index=0, axis=4, tilel1=out_c0, tilel0=0)  # c0

  402. 

  403.         if in_c1 > 1:

  404.             info.setdim(index=0, axis=5, tilel1=in_c1, tilel0=0)  # kc1

  405.         if k_h > 1:

  406.             info.setdim(index=0, axis=5, tilel1=k_h, tilel0=0)  # kh

  407.         if k_w > 1:

  408.             info.setdim(index=0, axis=5, tilel1=k_w, tilel0=0)  # kw

  409.         info.setdim(index=0, axis="KC0", tilel1=block_size, tilel0=0)  # kc0

  410.         return info

  411. 

  412.     def gen_dynamic_dim():

  413.         info = dim.Dim()

  414.         if dynamic:

  415.             info.setdim(index=0, axis=0, tilel1=1, tilel0=0)  # n

  416.         elif out_n > 1:

  417.             info.setdim(index=0, axis=0, tilel1=1, tilel0=0)  # n

  418. 

  419.         if dynamic_tiling:

  420.             info.setdim(index=0, axis=0, tilel1=c1_cut_fake, tilel0=0)  # c1

  421.         elif dynamic or out_c1 > 1:

  422.             info.setdim(index=0, axis=0, tilel1=c1_cut, tilel0=0)  # c1

  423. 

  424.         if dynamic_tiling:

  425.             info.setdim(index=0, axis="H", tilel1=tile_out_h_fake, tilel0=0)  # h

  426.         elif dynamic or out_h > 1:

  427.             info.setdim(index=0, axis="H", tilel1=tile_out_h, tilel0=0)  # h

  428. 

  429.         if dynamic_tiling:

  430.             info.setdim(index=0, axis="W", tilel1=tile_out_w_fake, tilel0=0)  # w

  431.         elif dynamic or out_w > 1:

  432.             info.setdim(index=0, axis="W", tilel1=tile_out_w, tilel0=0)  # w

  433. 

  434.         if dynamic or out_c0 > 1:

  435.             info.setdim(index=0, axis=4, tilel1=out_c0, tilel0=0)  # c0

  436. 

  437.         if dynamic and not use_autotiling:

  438.             info.setdim(index=0, axis=5, tilel1=dynamic_ci_c1, tilel0=0)  # kc1

  439.         elif dynamic or in_c1 > 1:

  440.             info.setdim(index=0, axis=5, tilel1=in_c1, tilel0=0)  # kc1

  441. 

  442.         if dynamic or k_h > 1:

  443.             info.setdim(index=0, axis=5, tilel1=k_h, tilel0=0)  # kh

  444. 

  445.         if dynamic or k_w > 1:

  446.             info.setdim(index=0, axis=5, tilel1=k_w, tilel0=0)  # kw

  447. 

  448.         info.setdim(index=0, axis="KC0", tilel1=block_size, tilel0=0)  # kc0

  449.         return info

  450. 

  451.     if dynamic:

  452.         info = gen_dynamic_dim()

  453.     else:

  454.         info = gen_static_dim()

  455.     tiling = str(info)

  456.     if use_autotiling:

  457.         tiling = ""

  458.         dynamic_ci_c1 = 215

  459.     return tiling, tiles, bypass, dynamic_ci_c1

  460. 

  461. 

  462. def conv_core(data, fmap_shape, filter_shape, pad, stride, dilation, use_bias=False, attrs=None):

  463.     """core computation for op conv."""

  464.     if use_bias:

  465.         if len(data) != 3:

  466.             raise IndexError("data should contain 3 tensors, i.e. feature map, filter and bias")

  467.         if data[2].dtype != "float16":

  468.             raise TypeError("data type of bias should be float16")

  469.     else:

  470.         if len(data) != 2:

  471.             raise IndexError("data should contain 2 tensors, i.e. feature map and filter")

  472.     if data[0].dtype != "float16":

  473.         raise TypeError("data type of feature map should be float16")

  474.     if data[1].dtype != "float16":

  475.         raise TypeError("data type of filter should be float16")

  476.     if not isinstance(use_bias, bool):

  477.         raise TypeError("use_bias should be set as False or True")

  478. 

  479.     all_dynamic = 0      # kh kw pad stride

  480.     partial_dynamic = 0  # fn fc1 fh fw wN wC

  481.     if attrs is None:

  482.         attrs = {}

  483.     if attrs.get("dynamic"):

  484.         all_dynamic = 1

  485.     if attrs.get("partial_dynamic"):

  486.         partial_dynamic = 1

  487.     dynamic = partial_dynamic or all_dynamic

  488.     dynamic_tiling = 1 if attrs.get("dynamic") else 0

  489.     use_autotiling = 1 if dynamic and not dynamic_tiling else 0

  490.     block_size = 16

  491. 

  492.     if not dynamic:

  493.         vc_util.convolution_format_check(fmap_shape, filter_shape, pad, stride, dilation)

  494.         for tmp_data in data:

  495.             shape = [x.value for x in tmp_data.shape]

  496.             vc_util.check_shape(shape)

  497.         vc_util.check_shape(fmap_shape)

  498.         vc_util.check_shape(filter_shape)

  499. 

  500.     stride_len = 2

  501.     pad_len = 4

  502.     dilation_len = 2

  503.     zero = 0

  504.     max_s = 63

  505.     max_d = 255

  506. 

  507.     if isinstance(stride, int):

  508.         stride = [stride] * stride_len

  509.     elif isinstance(stride, (list, tuple)) and len(stride) == 1:  # only has one element

  510.         stride = list(stride) * stride_len

  511.     elif isinstance(stride, (list, tuple)) and len(stride) == stride_len:

  512.         pass

  513.     else:

  514.         raise IndexError("stride para illegal !!!")

  515. 

  516.     if not dynamic:

  517.         for val in stride:

  518.             if val <= zero:

  519.                 raise ValueError("elements in stride should be greater than Zero !!!")

  520.             if val > max_s:

  521.                 raise ValueError("elements in stride should be less than 64 !!!")

  522. 

  523.     if isinstance(pad, int):

  524.         pad = [pad] * pad_len

  525.     elif isinstance(pad, (list, tuple)) and len(pad) == 1:  # only has one element

  526.         pad = list(pad) * pad_len

  527.     elif isinstance(pad, (list, tuple)) and len(pad) == pad_len:

  528.         pass

  529.     else:

  530.         raise IndexError("pad para illegal !!!")

  531. 

  532.     if not dynamic:

  533.         for val in pad:

  534.             if val < zero:

  535.                 raise ValueError("elements in pad should not be less than Zero !!!")

  536.             if val > max_d:

  537.                 raise ValueError("elements in pad should be less than 256 !!!")

  538. 

  539.     if isinstance(dilation, int):

  540.         dilation = [dilation] * dilation_len

  541.     elif isinstance(dilation, (list, tuple)) and len(dilation) == 1:  # only has one element

  542.         dilation = list(dilation) * dilation_len

  543.     elif isinstance(dilation, (list, tuple)) and len(dilation) == dilation_len:

  544.         pass

  545.     else:

  546.         raise IndexError("dilation para illegal !!!")

  547. 

  548.     for val in dilation:

  549.         if val <= zero:

  550.             raise ValueError("elements in dilation should be greater than Zero !!!")

  551.         if val > max_d:

  552.             raise ValueError("elements in dilation should be less than 256 !!!")

  553. 

  554.     if len(stride) != stride_len or len(pad) != pad_len or len(dilation) != dilation_len:

  555.         raise IndexError(" shape of parameters must be as expected")

  556. 

  557.     block_size_sub_one = block_size - 1

  558.     # input shape (NCHW -> NC1HWC0)

  559.     in_n, in_c, in_h, in_w = fmap_shape

  560.     in_c = (in_c + block_size_sub_one) // block_size * block_size

  561. 

  562.     # kernel shape (NCHW -> NC1HWC0 -> Fractal)

  563.     k_n, k_c, k_h, k_w = filter_shape

  564.     k_c = (k_c + block_size_sub_one) // block_size * block_size

  565.     k_n = (k_n + block_size_sub_one) // block_size * block_size

  566. 

  567.     # padding(padding_top, padding_bottom, padding_left, padding_right)

  568.     p_top, p_bottom, p_left, p_right = pad

  569. 

  570.     # stride (stride_h, stride_w)

  571.     s_h, s_w = stride

  572. 

  573.     k_h_real = k_h

  574.     k_w_real = k_w

  575.     p_top_real = p_top

  576.     p_bottom_real = p_bottom

  577.     p_left_real = p_left

  578.     p_right_real = p_right

  579.     s_h_real = s_h

  580.     s_w_real = s_w

  581. 

  582.     if dynamic_tiling:

  583.         k_h = k_h_fake

  584.         k_w = k_w_fake

  585.         p_top = p_top_fake

  586.         p_bottom = p_bottom_fake

  587.         p_left = p_left_fake

  588.         p_right = p_right_fake

  589.         s_h = s_h_fake

  590.         s_w = s_w_fake

  591. 

  592.     # dilation (dilation_h, dilation_w)

  593.     d_h, d_w = dilation

  594. 

  595.     # tiling

  596.     key = []

  597.     key.append(tuple(fmap_shape))

  598.     key.append(tuple(filter_shape))

  599.     key.append(tuple(pad))

  600.     key.append(tuple(stride))

  601.     key.append(tuple(dilation))

  602.     key.append(use_bias)

  603. 

  604.     hash_key = str(tuple(key))

  605. 

  606.     k_w_d = (k_w - 1) * d_w + 1

  607.     out_w = (in_w + p_left + p_right - k_w_d) // (s_w) + 1

  608. 

  609.     bypass_list = [0, 1]

  610.     bypass = 0 if dynamic else 1

  611. 

  612.     # (NC1HWCO)

  613.     a_value = data[0]

  614. 

  615.     # (fractal)

  616.     b_value = data[1]

  617.     setdim_map = conv_set_dim_map

  618. 

  619.     conv_tile_num = 5

  620.     if attrs is not None and "conv_tile" in attrs and len(attrs["conv_tile"]) >= conv_tile_num:

  621.         use_autotiling = 0

  622.         tile_hh = attrs["conv_tile"][0]

  623.         tile_coco = attrs["conv_tile"][1]

  624.         tile_mm = attrs["conv_tile"][2]

  625.         tile_kk = attrs["conv_tile"][3]

  626.         tile_nn = attrs["conv_tile"][4]

  627.         if len(attrs["conv_tile"]) > conv_tile_num:

  628.             tile_ww = attrs["conv_tile"][conv_tile_num]

  629.         else:

  630.             tile_ww = (out_w - 1) * s_w + k_w_d

  631.         if "bypass" in attrs:

  632.             bypass = attrs["bypass"]

  633.     elif hash_key in setdim_map:

  634.         configs = setdim_map[hash_key]

  635.         if isinstance(configs, tuple):

  636.             tiles = configs[0]

  637.             if "bypass" in configs[1]:

  638.                 bypass = configs[1]["bypass"]

  639.         else:

  640.             tiles = configs

  641.         if len(tiles) > conv_tile_num:

  642.             tile_hh, tile_coco, tile_mm, tile_kk, tile_nn, tile_ww = tiles

  643.         else:

  644.             tile_hh, tile_coco, tile_mm, tile_kk, tile_nn = tiles

  645.             tile_ww = (out_w - 1) * s_w + k_w_d

  646.     else:

  647.         win_cut_h = 1

  648.         k_h_d = (k_h - 1) * d_h + 1

  649.         win_h = (in_h + p_top + p_bottom - k_h_d) // (s_h) + 1

  650.         if not dynamic:

  651.             while win_cut_h <= win_h:

  652.                 if (((win_h + win_cut_h - 1) // win_cut_h - 1) * win_cut_h - 1) * s_h + k_h_d <= in_h + p_top:

  653.                     break

  654.                 win_cut_h += 1

  655.         tile_hh = (win_cut_h - 1) * s_h + k_h_d

  656.         tile_ww = (out_w - 1) * s_w + k_w_d

  657.         tile_coco = block_size

  658.         tile_mm = block_size

  659.         tile_kk = block_size

  660.         tile_nn = block_size

  661.     if bypass not in bypass_list:

  662.         raise ValueError("bypass of conv only supports %s" % (",".join(str(bypass_list))))

  663. 

  664.     if tile_hh == in_h:

  665.         tile_hh += p_top + p_bottom

  666. 

  667.     if tile_ww == in_w:

  668.         tile_ww += p_left + p_right

  669. 

  670.     tile_coco = (tile_coco + block_size_sub_one) // block_size * block_size

  671.     tile_mm = (tile_mm + block_size_sub_one) // block_size * block_size

  672.     tile_kk = (tile_kk + block_size_sub_one) // block_size * block_size

  673.     tile_nn = (tile_nn + block_size_sub_one) // block_size * block_size

  674. 

  675.     input_shape_nc1hwc0 = get_shape(data[0])

  676.     if not dynamic and input_shape_nc1hwc0 != [in_n, in_c // block_size, in_h, in_w, block_size]:

  677.         raise ValueError("feature map tensor data[0] shape illegal !!!")

  678.     in_n, c1_in, in_h, in_w, _ = input_shape_nc1hwc0

  679. 

  680.     if not dynamic:

  681.         kernel_shape_nc1hwc0 = (k_n, k_c // block_size, k_h, k_w, block_size)

  682.     else:

  683.         kernel_shape_nc1hwc0 = (k_n, c1_in, k_h, k_w, block_size)  # simplify for dynamic case

  684.     k_n, k_c1, k_h, k_w, k_c0 = kernel_shape_nc1hwc0

  685.     kernel_shape_fractal = get_shape(data[1])

  686.     if not dynamic and kernel_shape_fractal != [k_c1 * k_h * k_w, k_n // block_size, block_size, k_c0]:

  687.         raise ValueError("filter tensor data[1] shape illegal !!!")

  688. 

  689.     if use_bias:

  690.         bias_value = data[2]

  691.         bias_name = bias_value.op.name

  692.         bias_shape = [x.value for x in data[2].shape]

  693.         if bias_shape != [1, k_n // block_size, 1, 1, block_size]:

  694.             raise ValueError("bias tensor data[2] shape illegal !!!")

  695.     else:

  696.         bias_name = "None"

  697.         bias_value = None

  698. 

  699.     # Create reduction variables

  700.     kc1 = akg.tvm.reduce_axis((0, k_c1), name="kc1")

  701.     kh = akg.tvm.reduce_axis((0, k_h), name="kh")

  702.     kw = akg.tvm.reduce_axis((0, k_w), name="kw")

  703.     kc0 = akg.tvm.reduce_axis((0, k_c0), name="kc0")

  704. 

  705.     k_h_d = (k_h - 1) * d_h + 1

  706.     k_h_d_real = (k_h_real - 1) * d_h + 1

  707.     k_w_d = (k_w - 1) * d_w + 1

  708.     k_w_d_real = (k_w_real - 1) * d_w + 1

  709.     out_h = (in_h + p_top + p_bottom - k_h_d) // (s_h) + 1

  710.     tile_out_h = (tile_hh - k_h_d) // s_h + 1

  711.     tile_out_h_real = (tile_hh - k_h_d_real) // s_h_real + 1

  712.     out_w = (in_w + p_left + p_right - k_w_d) // (s_w) + 1

  713.     tile_out_w = (tile_ww - k_w_d) // s_w + 1

  714.     tile_out_w_real = (tile_ww - k_w_d_real) // s_w_real + 1

  715. 

  716.     if not dynamic:

  717.         out_shape_nc1hwc0 = (in_n, k_n // block_size, out_h, out_w, block_size)

  718.     else:

  719.         _, c1_out, _, _ = data[1].shape

  720.         out_shape_nc1hwc0 = (in_n, c1_out, out_h, out_w, block_size)

  721.     _, out_c1, out_h, out_w, _ = out_shape_nc1hwc0

  722. 

  723.     if tile_coco > 0:

  724.         c1_cut = tile_coco // block_size

  725.     else:

  726.         c1_cut = out_c1

  727. 

  728.     # Compute the convolution

  729.     output_name = "output0"

  730.     conv_attr = {

  731.         "pragma_conv_kernel_n": k_n,

  732.         "pragma_conv_kernel_h": k_h,

  733.         "pragma_conv_kernel_w": k_w,

  734.         "pragma_conv_padding_top": p_top,

  735.         "pragma_conv_padding_bottom": p_bottom,

  736.         "pragma_conv_padding_left": p_left,

  737.         "pragma_conv_padding_right": p_right,

  738.         "pragma_conv_bypass_l1": bypass,

  739.         "pragma_conv_stride_h": s_h,

  740.         "pragma_conv_stride_w": s_w,

  741.         "pragma_conv_dilation_h": d_h,

  742.         "pragma_conv_dilation_w": d_w,

  743.         "pragma_conv_fm_n": in_n,

  744.         "pragma_conv_fm_c": in_c,

  745.         "pragma_conv_fm_h": in_h,

  746.         "pragma_conv_fm_w": in_w,

  747.         "feature": a_value.op.name,

  748.         "filter": b_value.op.name,

  749.         "bias": bias_name,

  750.         "res": output_name}

  751. 

  752.     if dynamic_tiling:

  753.         conv_attr["pragma_conv_h_cut"] = (tile_out_h_fake - 1) * s_h + k_h_d

  754.         conv_attr["pragma_conv_w_cut"] = (tile_out_w_fake - 1) * s_w + k_w_d

  755.         conv_attr["pragma_conv_co_cut"] = c1_cut_fake * 16

  756.         conv_attr["pragma_conv_m_cut"] = m_cut_fake

  757.         conv_attr["pragma_conv_k_cut"] = k_cut_fake

  758.         conv_attr["pragma_conv_n_cut"] = n_cut_fake

  759.         conv_attr["pragma_conv_tile_co"] = c1_cut

  760.         conv_attr["pragma_conv_tile_ho"] = tile_out_h_real

  761.         conv_attr["pragma_conv_tile_wo"] = tile_out_w_real

  762.         conv_attr["pragma_conv_tile_mo"] = tile_mm // 16

  763.         conv_attr["pragma_conv_tile_ko"] = tile_kk // 16

  764.         conv_attr["pragma_conv_tile_no"] = tile_nn // 16

  765.         conv_attr["pragma_conv_real_kh"] = k_h_real

  766.         conv_attr["pragma_conv_real_kw"] = k_w_real

  767.         conv_attr["pragma_conv_real_sh"] = s_h_real

  768.         conv_attr["pragma_conv_real_sw"] = s_w_real

  769.         conv_attr["pragma_conv_real_pt"] = p_top_real

  770.         conv_attr["pragma_conv_real_pb"] = p_bottom_real

  771.         conv_attr["pragma_conv_real_pl"] = p_left_real

  772.         conv_attr["pragma_conv_real_pr"] = p_right_real

  773.     elif not use_autotiling:

  774.         conv_attr["pragma_conv_h_cut"] = (tile_out_h - 1) * s_h + k_h_d

  775.         conv_attr["pragma_conv_w_cut"] = (tile_out_w - 1) * s_w + k_w_d

  776.         conv_attr["pragma_conv_co_cut"] = c1_cut * k_c0

  777.         conv_attr["pragma_conv_m_cut"] = tile_mm

  778.         conv_attr["pragma_conv_k_cut"] = tile_kk

  779.         conv_attr["pragma_conv_n_cut"] = tile_nn

  780.     c_value = akg.tvm.compute(out_shape_nc1hwc0,

  781.                               lambda n, c1, h, w, c0: akg.lang.cce.mmad(

  782.                                   (akg.tvm.if_then_else(akg.tvm.any((h * s_h + kh) < p_top,

  783.                                                                     (h * s_h + kh) > (in_h + p_top - 1),

  784.                                                                     (w * s_w + kw) < p_left,

  785.                                                                     (w * s_w + kw) > (in_w + p_left - 1)),

  786.                                                         akg.tvm.const(0.0, "float16"),

  787.                                                         a_value[n, kc1, (h * s_h + (kh * d_h) - p_top),

  788.                                                                 (w * s_w + (kw * d_w) - p_left), kc0])

  789.                                    * b_value[(kc1 * k_h + kh) * k_w + kw, c1, c0, kc0]).astype("float32"),

  790.                                   axis=[kc1, kh, kw, kc0]), name=output_name,

  791.                               attrs=conv_attr)

  792.     return c_value

  793. 

  794. @vc_util.check_input_type((list, tuple), (list, tuple), (list, tuple), (list, tuple), (list, tuple), (list, tuple),

  795.                           (bool, type(None)), (dict, type(None)), (list, tuple, type(None)))

  796. def conv(data, fmap_shape, filter_shape, pad, stride, dilation, use_bias=False, attrs=None, params=None):

  797.     """

  798.     Computes sums of 5-D convolutionis.

  799. 

  800.     Args:

  801.         data (list[tvm.tensor.Tensor]): the size is 3 if use_bias else the size is 2;

  802.               data[0] Tensor of type float16 ,shape 5D (fN, fC // C0, C0, fH, fW)

  803.               data[1] Tensor of type float16 ,shape 4D (wC // C0 * wH * wW, wN // C0, C0, C0)

  804.               data[2] Tensor of type float16 ,shape 5D (1, wN // C0, 1, 1, 16)

  805.         fmap_shape (list[int]): [fN, fC, fH, fW]

  806.         filter_shape (list[int]): [wN, wC, wH, wW]

  807.         pad (list[int]): [pad_top, pad_bottom, pad_left, pad_right]

  808.         stride (list[int]): [stride_h, stride_w]

  809.         dilation (list[int]): [dilation_h, dilation_w]

  810.         use_bias (bool): bool var.

  811.         attrs (dict): dict with keys for example: conv_tile,bypass

  812. 

  813.     Returns:

  814.         tvm.tensor.Tensor of same type as data, shape is 5D(oN, oC // C0, oH, oW, C0)

  815.     """

  816.     c_value = conv_core(data, fmap_shape, filter_shape, pad, stride, dilation, use_bias, attrs)

  817.     c_value = cast.cast(c_value, "float16")

  818. 

  819.     if use_bias:

  820.         bias_value = data[2]

  821.         output_bias_name = "output1"

  822.         cube = akg.tvm.compute(c_value.shape, lambda n, c1, h, w, c0: c_value[n, c1, h, w, c0] +

  823.                                bias_value[0, c1, 0, 0, c0],

  824.                                name=output_bias_name)

  825.     else:

  826.         cube = c_value

  827. 

  828.     block_size = 16

  829.     dim_info, _, _, dynamic_ci_c1 = conv_set_dim_func(fmap_shape, filter_shape, pad, stride, dilation,

  830.                                                       use_bias, block_size, attrs, conv_set_dim_map)

  831. 

  832.     all_dynamic = 0      # kh kw pad stride

  833.     partial_dynamic = 0  # fn fc1 fh fw wN wC

  834.     dynamic_tiling_full_dynamic = 1  # kh, kw, pad, stride are parameters if dynamic_tiling is enabled

  835. 

  836.     if attrs is None:

  837.         attrs = {}

  838.     if attrs.get("dynamic"):

  839.         all_dynamic = 1

  840.     if attrs.get("partial_dynamic"):

  841.         partial_dynamic = 1

  842.     dynamic = partial_dynamic or all_dynamic

  843.     dynamic_tiling = 1 if attrs.get("dynamic") else 0

  844. 

  845.     if not dynamic:

  846.         attrs = {"dim": dim_info, "pragma_reschedule": 1, "pragma_rmselfdep": 0}

  847.     else:

  848.         attrs = {"dim": dim_info,

  849.                  "pragma_reschedule": 1,

  850.                  "pragma_rmselfdep": 0,

  851.                  "enable_fix_loop_extent": 0,

  852.                  "enable_post_poly_loop_partition": 0,

  853.                  "enable_isolate_loop": 0,

  854.                  "enable_isolate_min_max": 1,

  855.                  "enable_conv_analyze_align": 0,

  856.                  "enable_double_buffer": 1,

  857.                  "enable_multicore": 1,

  858.                  "enable_invariant_hoist": 1,

  859.                  "pragma_keep_outer_band_order": 1,

  860.                  "enable_algebra_simplify": 1,

  861.                  "dynamic_shape_conv_full_parametric": dynamic_tiling and dynamic_tiling_full_dynamic,

  862.                  }

  863.         attrs["pragma_outerband_need_split"] = 1

  864.         attrs["pragma_is_conv"] = 1

  865.         if dynamic_tiling:

  866.             attrs["dynamic_shape"] = set_poly_upper_bound_for_tensor(data[0], 129, 1)  # pos 1 of data[0] is CI1 axis

  867.         else:

  868.             attrs["dynamic_shape"] = set_poly_upper_bound_for_tensor(

  869.                 data[0], dynamic_ci_c1 + 1, 1)  # pos 1 of data[0] is CI1 axis

  870.         if dynamic_tiling:

  871.             attrs["pragma_tilesize_is_var"] = 1

  872.             attrs["enable_stride_kernel_op"] = 0

  873. 

  874.     return cube, attrs