Beispiel #1
0
 def main(placeholder: T.Buffer[(301056, ), "int8"],
          ethosu_write: T.Buffer[(75264, ), "int8"]) -> None:
     T.func_attr({
         "from_legacy_te_schedule": True,
         "global_symbol": "main",
         "tir.noalias": True
     })
     buffer1 = T.buffer_decl([2848], "uint8")
     buffer3 = T.buffer_decl([976], "uint8")
     p1 = T.allocate([2848],
                     "uint8",
                     "global",
                     annotations={"disable_lower_builtin": True})
     p2 = T.allocate([976],
                     "uint8",
                     "global",
                     annotations={"disable_lower_builtin": True})
     p5 = T.allocate([75264],
                     "int8",
                     "global",
                     annotations={"disable_lower_builtin": True})
     p6 = T.allocate([75264],
                     "int8",
                     "global",
                     annotations={"disable_lower_builtin": True})
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer1[0],
                       2848,
                       p1[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer3[0],
                       976,
                       p2[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       56,
                       56,
                       96,
                       56,
                       0,
                       56,
                       placeholder[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       5376,
                       96,
                       1,
                       "int8",
                       56,
                       56,
                       24,
                       56,
                       0,
                       56,
                       p5[0],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       1344,
                       24,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       p1[0],
                       2608,
                       T.int8(-1),
                       T.int8(-1),
                       12,
                       p1[2608],
                       240,
                       T.int8(-1),
                       T.int8(-1),
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       0,
                       0,
                       0,
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       56,
                       56,
                       24,
                       56,
                       0,
                       56,
                       p5[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       1344,
                       24,
                       1,
                       "int8",
                       56,
                       56,
                       24,
                       56,
                       0,
                       56,
                       p6[0],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       1344,
                       24,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       p2[0],
                       736,
                       T.int8(-1),
                       T.int8(-1),
                       12,
                       p2[736],
                       240,
                       T.int8(-1),
                       T.int8(-1),
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       0,
                       0,
                       0,
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_binary_elementwise",
                       "int8",
                       56,
                       56,
                       24,
                       56,
                       0,
                       56,
                       p5[0],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1344,
                       24,
                       1,
                       "int8",
                       56,
                       56,
                       24,
                       56,
                       0,
                       56,
                       p6[0],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1344,
                       24,
                       1,
                       "int8",
                       56,
                       56,
                       24,
                       56,
                       0,
                       56,
                       ethosu_write[0],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1344,
                       24,
                       1,
                       "ADD",
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       0,
                       0,
                       0,
                       dtype="handle"))
 def main(placeholder: T.Buffer[(24, ), "int8"],
          T_concat: T.Buffer[(24, ), "int8"]) -> None:
     # function attr dict
     T.func_attr({
         "from_legacy_te_schedule": True,
         "global_symbol": "main",
         "tir.noalias": True
     })
     T.preflattened_buffer(placeholder, [1, 2, 3, 4],
                           dtype="int8",
                           data=placeholder.data)
     T.preflattened_buffer(T_concat, [24],
                           dtype="int8",
                           data=T_concat.data)
     # body
     ethosu_write = T.allocate([12], "int8", "global")
     T.evaluate(
         T.call_extern("ethosu_identity",
                       "int8",
                       1,
                       3,
                       4,
                       1,
                       0,
                       3,
                       placeholder[12],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1,
                       4,
                       1,
                       "int8",
                       1,
                       3,
                       4,
                       1,
                       0,
                       3,
                       ethosu_write[0],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1,
                       4,
                       1,
                       "AVG",
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     ethosu_write_1 = T.allocate([12], "int8", "global")
     T.evaluate(
         T.call_extern("ethosu_identity",
                       "int8",
                       1,
                       3,
                       4,
                       1,
                       0,
                       3,
                       ethosu_write[0],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1,
                       4,
                       1,
                       "int8",
                       1,
                       3,
                       4,
                       1,
                       0,
                       3,
                       ethosu_write_1[0],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1,
                       4,
                       1,
                       "AVG",
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_identity",
                       "int8",
                       12,
                       1,
                       1,
                       12,
                       0,
                       1,
                       ethosu_write_1[0],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1,
                       1,
                       1,
                       "int8",
                       12,
                       1,
                       1,
                       12,
                       0,
                       1,
                       T_concat[12],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1,
                       1,
                       1,
                       "AVG",
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     ethosu_write_2 = T.allocate([12], "int8", "global")
     T.evaluate(
         T.call_extern("ethosu_identity",
                       "int8",
                       1,
                       3,
                       4,
                       1,
                       0,
                       3,
                       placeholder[0],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1,
                       4,
                       1,
                       "int8",
                       1,
                       3,
                       4,
                       1,
                       0,
                       3,
                       ethosu_write_2[0],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1,
                       4,
                       1,
                       "AVG",
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     ethosu_write_3 = T.allocate([12], "int8", "global")
     T.evaluate(
         T.call_extern("ethosu_identity",
                       "int8",
                       1,
                       3,
                       4,
                       1,
                       0,
                       3,
                       ethosu_write_2[0],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1,
                       4,
                       1,
                       "int8",
                       1,
                       3,
                       4,
                       1,
                       0,
                       3,
                       ethosu_write_3[0],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1,
                       4,
                       1,
                       "AVG",
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_identity",
                       "int8",
                       12,
                       1,
                       1,
                       12,
                       0,
                       1,
                       ethosu_write_3[0],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1,
                       1,
                       1,
                       "int8",
                       12,
                       1,
                       1,
                       12,
                       0,
                       1,
                       T_concat[0],
                       0,
                       0,
                       0,
                       T.float32(1),
                       0,
                       "NHWC",
                       1,
                       1,
                       1,
                       "AVG",
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
 def main(placeholder: T.Buffer[(8192, ), "int8"],
          ethosu_write: T.Buffer[(2048, ), "int8"],
          buffer_encoded: T.Buffer[(128, ), "uint8"],
          buffer_encoded_1: T.Buffer[(32, ), "uint8"],
          buffer_encoded_2: T.Buffer[(112, ), "uint8"],
          buffer_encoded_3: T.Buffer[(32, ), "uint8"],
          buffer_encoded_4: T.Buffer[(112, ), "uint8"],
          buffer_encoded_5: T.Buffer[(32, ), "uint8"],
          buffer_encoded_6: T.Buffer[(112, ), "uint8"],
          buffer_encoded_7: T.Buffer[(32, ), "uint8"]) -> None:
     # function attr dict
     T.func_attr({
         "from_legacy_te_schedule": True,
         "global_symbol": "main",
         "tir.noalias": True
     })
     T.preflattened_buffer(placeholder, [1, 16, 16, 32],
                           dtype="int8",
                           data=placeholder.data)
     T.preflattened_buffer(ethosu_write, [1, 16, 16, 8],
                           dtype="int8",
                           data=ethosu_write.data)
     # body
     placeholder_global = T.allocate([128], "uint8", "global")
     placeholder_global_1 = T.allocate([112], "uint8", "global")
     placeholder_global_2 = T.allocate([112], "uint8", "global")
     placeholder_d_global = T.allocate([32], "uint8", "global")
     placeholder_d_global_1 = T.allocate([32], "uint8", "global")
     placeholder_d_global_2 = T.allocate([32], "uint8", "global")
     placeholder_global_3 = T.allocate([112], "uint8", "global")
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_encoded[0],
                       128,
                       placeholder_global[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_encoded_1[0],
                       32,
                       placeholder_d_global[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       32,
                       16,
                       0,
                       16,
                       placeholder[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       512,
                       32,
                       1,
                       "int8",
                       16,
                       16,
                       2,
                       16,
                       0,
                       16,
                       ethosu_write[0],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       128,
                       8,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       placeholder_global[0],
                       128,
                       12,
                       placeholder_d_global[0],
                       32,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       0,
                       0,
                       0,
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_encoded_2[0],
                       112,
                       placeholder_global_1[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_encoded_3[0],
                       32,
                       placeholder_d_global_1[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       32,
                       16,
                       0,
                       16,
                       placeholder[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       512,
                       32,
                       1,
                       "int8",
                       16,
                       16,
                       2,
                       16,
                       0,
                       16,
                       ethosu_write[2],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       128,
                       8,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       placeholder_global_1[0],
                       112,
                       12,
                       placeholder_d_global_1[0],
                       32,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       0,
                       0,
                       0,
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_encoded_4[0],
                       112,
                       placeholder_global_2[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_encoded_5[0],
                       32,
                       placeholder_d_global_2[0],
                       dtype="handle"))
     placeholder_d_global_3 = T.allocate([32], "uint8", "global")
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       32,
                       16,
                       0,
                       16,
                       placeholder[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       512,
                       32,
                       1,
                       "int8",
                       16,
                       16,
                       2,
                       16,
                       0,
                       16,
                       ethosu_write[4],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       128,
                       8,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       placeholder_global_2[0],
                       112,
                       12,
                       placeholder_d_global_2[0],
                       32,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       0,
                       0,
                       0,
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_encoded_6[0],
                       112,
                       placeholder_global_3[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_encoded_7[0],
                       32,
                       placeholder_d_global_3[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       32,
                       16,
                       0,
                       16,
                       placeholder[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       512,
                       32,
                       1,
                       "int8",
                       16,
                       16,
                       2,
                       16,
                       0,
                       16,
                       ethosu_write[6],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       128,
                       8,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       placeholder_global_3[0],
                       112,
                       12,
                       placeholder_d_global_3[0],
                       32,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       0,
                       0,
                       0,
                       dtype="handle"))
Beispiel #4
0
 def main(placeholder: T.handle, ethosu_write: T.handle, placeholder_1: T.handle, placeholder_2: T.handle, placeholder_3: T.handle, placeholder_4: T.handle, placeholder_5: T.handle, placeholder_6: T.handle, placeholder_7: T.handle, placeholder_8: T.handle) -> None:
     # function attr dict
     T.func_attr({"from_legacy_te_schedule": True, "global_symbol": "main", "tir.noalias": True})
     buffer = T.match_buffer(placeholder_7, [112], dtype="uint8", elem_offset=0, align=128, offset_factor=1)
     buffer_1 = T.match_buffer(placeholder_4, [32], dtype="uint8", elem_offset=0, align=128, offset_factor=1)
     buffer_2 = T.match_buffer(placeholder_2, [32], dtype="uint8", elem_offset=0, align=128, offset_factor=1)
     buffer_3 = T.match_buffer(placeholder_8, [32], dtype="uint8", elem_offset=0, align=128, offset_factor=1)
     buffer_4 = T.match_buffer(placeholder_5, [112], dtype="uint8", elem_offset=0, align=128, offset_factor=1)
     placeholder_9 = T.match_buffer(placeholder, [1, 16, 16, 32], dtype="int8", elem_offset=0, align=128, offset_factor=1)
     buffer_5 = T.match_buffer(placeholder_3, [112], dtype="uint8", elem_offset=0, align=128, offset_factor=1)
     buffer_6 = T.match_buffer(placeholder_1, [128], dtype="uint8", elem_offset=0, align=128, offset_factor=1)
     ethosu_write_1 = T.match_buffer(ethosu_write, [1, 16, 16, 8], dtype="int8", elem_offset=0, align=128, offset_factor=1)
     buffer_7 = T.match_buffer(placeholder_6, [32], dtype="uint8", elem_offset=0, align=128, offset_factor=1)
     # body
     placeholder_global = T.allocate([128], "uint8", "global")
     placeholder_d_global = T.allocate([32], "uint8", "global")
     T.evaluate(T.call_extern("ethosu_copy", T.load("uint8", buffer_6.data, 0), 128, T.load("uint8", placeholder_global, 0), dtype="handle"))
     T.evaluate(T.call_extern("ethosu_copy", T.load("uint8", buffer_2.data, 0), 32, T.load("uint8", placeholder_d_global, 0), dtype="handle"))
     T.evaluate(T.call_extern("ethosu_conv2d", "int8", 16, 16, 32, 16, 0, 16, T.load("int8", placeholder_9.data, 0), 0, 0, 0, T.float32(0.5), 10, "NHWC", 512, 32, 1, "int8", 16, 16, 2, 16, 0, 16, T.load("int8", ethosu_write_1.data, 0), 0, 0, 0, T.float32(0.25), 14, "NHWC", 128, 8, 1, 1, 1, 1, 1, 1, 1, T.load("uint8", placeholder_global, 0), 128, 12, T.load("uint8", placeholder_d_global, 0), 32, 0, 0, 0, 0, "NONE", 0, 0, "NONE", dtype="handle"))
     T.evaluate(T.call_extern("ethosu_copy", T.load("uint8", buffer_5.data, 0), 112, T.load("uint8", placeholder_global, 0), dtype="handle"))
     T.evaluate(T.call_extern("ethosu_copy", T.load("uint8", buffer_1.data, 0), 32, T.load("uint8", placeholder_d_global, 0), dtype="handle"))
     T.evaluate(T.call_extern("ethosu_conv2d", "int8", 16, 16, 32, 16, 0, 16, T.load("int8", placeholder_9.data, 0), 0, 0, 0, T.float32(0.5), 10, "NHWC", 512, 32, 1, "int8", 16, 16, 2, 16, 0, 16, T.load("int8", ethosu_write_1.data, 2), 0, 0, 0, T.float32(0.25), 14, "NHWC", 128, 8, 1, 1, 1, 1, 1, 1, 1, T.load("uint8", placeholder_global, 0), 112, 12, T.load("uint8", placeholder_d_global, 0), 32, 0, 0, 0, 0, "NONE", 0, 0, "NONE", dtype="handle"))
     T.evaluate(T.call_extern("ethosu_copy", T.load("uint8", buffer_4.data, 0), 112, T.load("uint8", placeholder_global, 0), dtype="handle"))
     T.evaluate(T.call_extern("ethosu_copy", T.load("uint8", buffer_7.data, 0), 32, T.load("uint8", placeholder_d_global, 0), dtype="handle"))
     T.evaluate(T.call_extern("ethosu_conv2d", "int8", 16, 16, 32, 16, 0, 16, T.load("int8", placeholder_9.data, 0), 0, 0, 0, T.float32(0.5), 10, "NHWC", 512, 32, 1, "int8", 16, 16, 2, 16, 0, 16, T.load("int8", ethosu_write_1.data, 4), 0, 0, 0, T.float32(0.25), 14, "NHWC", 128, 8, 1, 1, 1, 1, 1, 1, 1, T.load("uint8", placeholder_global, 0), 112, 12, T.load("uint8", placeholder_d_global, 0), 32, 0, 0, 0, 0, "NONE", 0, 0, "NONE", dtype="handle"))
     T.evaluate(T.call_extern("ethosu_copy", T.load("uint8", buffer.data, 0), 112, T.load("uint8", placeholder_global, 0), dtype="handle"))
     T.evaluate(T.call_extern("ethosu_copy", T.load("uint8", buffer_3.data, 0), 32, T.load("uint8", placeholder_d_global, 0), dtype="handle"))
     T.evaluate(T.call_extern("ethosu_conv2d", "int8", 16, 16, 32, 16, 0, 16, T.load("int8", placeholder_9.data, 0), 0, 0, 0, T.float32(0.5), 10, "NHWC", 512, 32, 1, "int8", 16, 16, 2, 16, 0, 16, T.load("int8", ethosu_write_1.data, 6), 0, 0, 0, T.float32(0.25), 14, "NHWC", 128, 8, 1, 1, 1, 1, 1, 1, 1, T.load("uint8", placeholder_global, 0), 112, 12, T.load("uint8", placeholder_d_global, 0), 32, 0, 0, 0, 0, "NONE", 0, 0, "NONE", dtype="handle"))
 def main(placeholder: T.Buffer[(3402, ), "int8"],
          placeholder_encoded: T.Buffer[(128, ), "uint8"],
          placeholder_encoded_1: T.Buffer[(32, ), "uint8"],
          placeholder_encoded_2: T.Buffer[(128, ), "uint8"],
          placeholder_encoded_3: T.Buffer[(32, ), "uint8"],
          ethosu_write: T.Buffer[(3402, ), "int8"]) -> None:
     # function attr dict
     T.func_attr({
         "from_legacy_te_schedule": True,
         "global_symbol": "main",
         "tir.noalias": True
     })
     T.preflattened_buffer(placeholder, [1, 27, 42, 3],
                           dtype="int8",
                           data=placeholder.data)
     T.preflattened_buffer(placeholder_encoded, [3, 3, 2, 3],
                           dtype="int8")
     T.preflattened_buffer(placeholder_encoded_1, [3, 10],
                           dtype="uint8")
     T.preflattened_buffer(placeholder_encoded_2, [3, 3, 2, 3],
                           dtype="int8")
     T.preflattened_buffer(placeholder_encoded_3, [3, 10],
                           dtype="uint8")
     T.preflattened_buffer(ethosu_write, [1, 27, 42, 3],
                           dtype="int8",
                           data=ethosu_write.data)
     # body
     placeholder_global = T.allocate([128], "uint8", "global")
     T.evaluate(
         T.call_extern("ethosu_copy",
                       placeholder_encoded[0],
                       128,
                       placeholder_global[0],
                       dtype="handle"))
     placeholder_d_global = T.allocate([32], "uint8", "global")
     T.evaluate(
         T.call_extern("ethosu_copy",
                       placeholder_encoded_1[0],
                       32,
                       placeholder_d_global[0],
                       dtype="handle"))
     ethosu_write_2 = T.allocate([18144], "int8", "global")
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       27,
                       42,
                       3,
                       27,
                       0,
                       42,
                       placeholder[0],
                       0,
                       0,
                       0,
                       T.float32(0.0039215646684169769),
                       -128,
                       "NHWC",
                       126,
                       3,
                       1,
                       "int8",
                       27,
                       42,
                       3,
                       27,
                       0,
                       42,
                       ethosu_write_2[0],
                       0,
                       0,
                       0,
                       T.float32(0.031308155506849289),
                       -128,
                       "NHCWB16",
                       672,
                       16,
                       1,
                       2,
                       3,
                       1,
                       1,
                       1,
                       2,
                       placeholder_global[0],
                       128,
                       0,
                       placeholder_d_global[0],
                       32,
                       2,
                       0,
                       2,
                       1,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     placeholder_d_global_1 = T.allocate([128], "uint8", "global")
     T.evaluate(
         T.call_extern("ethosu_copy",
                       placeholder_encoded_2[0],
                       128,
                       placeholder_d_global_1[0],
                       dtype="handle"))
     placeholder_d_global_2 = T.allocate([32], "uint8", "global")
     T.evaluate(
         T.call_extern("ethosu_copy",
                       placeholder_encoded_3[0],
                       32,
                       placeholder_d_global_2[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       27,
                       42,
                       3,
                       27,
                       0,
                       42,
                       ethosu_write_2[0],
                       0,
                       0,
                       0,
                       T.float32(0.031308155506849289),
                       -128,
                       "NHCWB16",
                       672,
                       16,
                       1,
                       "int8",
                       27,
                       42,
                       3,
                       27,
                       0,
                       42,
                       ethosu_write[0],
                       0,
                       0,
                       0,
                       T.float32(0.23604340851306915),
                       -128,
                       "NHWC",
                       126,
                       3,
                       1,
                       2,
                       3,
                       1,
                       1,
                       1,
                       2,
                       placeholder_d_global_1[0],
                       128,
                       0,
                       placeholder_d_global_2[0],
                       32,
                       2,
                       0,
                       2,
                       1,
                       "CLIP",
                       -128,
                       127,
                       "TFL",
                       "NONE",
                       dtype="handle"))
Beispiel #6
0
 def main(placeholder: T.Buffer[(1536, ), "int8"],
          placeholder_1: T.Buffer[(1280, ), "int8"],
          T_concat: T.Buffer[(4096, ), "int8"]) -> None:
     # function attr dict
     T.func_attr({
         "from_legacy_te_schedule": True,
         "global_symbol": "main",
         "tir.noalias": True
     })
     buffer = T.buffer_decl([2992], "uint8")
     buffer_1 = T.buffer_decl([160], "uint8")
     buffer_2 = T.buffer_decl([2992], "uint8")
     buffer_3 = T.buffer_decl([160], "uint8")
     buffer_4 = T.buffer_decl([2992], "uint8")
     buffer_5 = T.buffer_decl([160], "uint8")
     buffer_6 = T.buffer_decl([2992], "uint8")
     buffer_7 = T.buffer_decl([160], "uint8")
     T.preflattened_buffer(placeholder, [1, 8, 12, 16],
                           "int8",
                           data=placeholder.data)
     T.preflattened_buffer(placeholder_1, [1, 8, 10, 16],
                           "int8",
                           data=placeholder_1.data)
     T.preflattened_buffer(T_concat, [1, 8, 32, 16],
                           "int8",
                           data=T_concat.data)
     # body
     T_concat_1 = T.allocate([2816],
                             "int8",
                             "global",
                             annotations={"disable_lower_builtin": True})
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       8,
                       10,
                       16,
                       8,
                       0,
                       10,
                       placeholder_1[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       160,
                       16,
                       1,
                       "int8",
                       8,
                       10,
                       16,
                       8,
                       0,
                       10,
                       T_concat_1[192],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       352,
                       16,
                       1,
                       3,
                       3,
                       1,
                       1,
                       1,
                       1,
                       buffer[0],
                       2992,
                       T.int8(-1),
                       T.int8(-1),
                       12,
                       buffer_1[0],
                       160,
                       T.int8(-1),
                       T.int8(-1),
                       1,
                       1,
                       1,
                       1,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       0,
                       0,
                       0,
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       8,
                       10,
                       16,
                       8,
                       0,
                       10,
                       T_concat_1[192],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       352,
                       16,
                       1,
                       "int8",
                       8,
                       10,
                       16,
                       8,
                       0,
                       10,
                       T_concat[352],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       512,
                       16,
                       1,
                       3,
                       3,
                       1,
                       1,
                       1,
                       1,
                       buffer_2[0],
                       2992,
                       T.int8(-1),
                       T.int8(-1),
                       12,
                       buffer_3[0],
                       160,
                       T.int8(-1),
                       T.int8(-1),
                       1,
                       1,
                       1,
                       1,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       0,
                       0,
                       0,
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       8,
                       12,
                       16,
                       8,
                       0,
                       12,
                       placeholder[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       192,
                       16,
                       1,
                       "int8",
                       8,
                       12,
                       16,
                       8,
                       0,
                       12,
                       T_concat_1[0],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       352,
                       16,
                       1,
                       3,
                       3,
                       1,
                       1,
                       1,
                       1,
                       buffer_4[0],
                       2992,
                       T.int8(-1),
                       T.int8(-1),
                       12,
                       buffer_5[0],
                       160,
                       T.int8(-1),
                       T.int8(-1),
                       1,
                       1,
                       1,
                       1,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       0,
                       0,
                       0,
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       8,
                       22,
                       16,
                       8,
                       0,
                       22,
                       T_concat_1[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       352,
                       16,
                       1,
                       "int8",
                       8,
                       22,
                       16,
                       8,
                       0,
                       22,
                       T_concat[0],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       512,
                       16,
                       1,
                       3,
                       3,
                       1,
                       1,
                       1,
                       1,
                       buffer_6[0],
                       2992,
                       T.int8(-1),
                       T.int8(-1),
                       12,
                       buffer_7[0],
                       160,
                       T.int8(-1),
                       T.int8(-1),
                       1,
                       1,
                       1,
                       1,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       0,
                       0,
                       0,
                       dtype="handle"))
Beispiel #7
0
 def main(
     placeholder: T.handle,
     placeholder_1: T.handle,
     placeholder_2: T.handle,
     ethosu_conv2d: T.handle,
 ) -> None:
     # function attr dict
     T.func_attr({"global_symbol": "main", "tir.noalias": True})
     placeholder_3 = T.match_buffer(
         placeholder, [1, 8, 8, 3], dtype="uint8", elem_offset=0, align=128, offset_factor=1
     )
     placeholder_4 = T.match_buffer(
         placeholder_1, [48], dtype="uint8", elem_offset=0, align=128, offset_factor=1
     )
     placeholder_5 = T.match_buffer(
         placeholder_2, [16], dtype="int32", elem_offset=0, align=128, offset_factor=1
     )
     ethosu_conv2d_1 = T.match_buffer(
         ethosu_conv2d, [1, 8, 8, 16], dtype="uint8", elem_offset=0, align=128, offset_factor=1
     )
     # body
     T.evaluate(
         T.call_extern(
             "ethosu_conv2d",
             "uint8",
             8,
             8,
             3,
             8,
             0,
             8,
             T.load("uint8", placeholder_3.data, 0),
             0,
             0,
             0,
             T.float32(0.5),
             10,
             "NHWC",
             24,
             3,
             1,
             "uint8",
             8,
             8,
             16,
             8,
             0,
             8,
             T.load("uint8", ethosu_conv2d_1.data, 0),
             0,
             0,
             0,
             T.float32(0.25),
             14,
             "NHWC",
             128,
             16,
             1,
             1,
             1,
             1,
             1,
             1,
             1,
             T.load("uint8", placeholder_4.data, 0),
             0,
             12,
             T.load("uint8", placeholder_5.data, 0),
             0,
             0,
             0,
             0,
             0,
             "CLIP",
             0,
             0,
             "TFL",
             "NONE",
             dtype="uint8",
         )
     )
Beispiel #8
0
 def main(placeholder_3: T.Buffer[(8192, ), "int8"],
          ethosu_write_1: T.Buffer[(2048, ), "int8"]) -> None:
     # function attr dict
     T.func_attr({
         "from_legacy_te_schedule": True,
         "global_symbol": "main",
         "tir.noalias": True
     })
     buffer_1 = T.buffer_decl([384], "uint8")
     # body
     placeholder_global = T.allocate(
         [384],
         "uint8",
         "global",
         annotations={"disable_lower_builtin": True})
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_1[0],
                       384,
                       placeholder_global[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       32,
                       16,
                       0,
                       16,
                       placeholder_3[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       512,
                       32,
                       1,
                       "int8",
                       16,
                       16,
                       8,
                       16,
                       0,
                       16,
                       ethosu_write_1[0],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       128,
                       8,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       placeholder_global[0],
                       304,
                       T.int8(-1),
                       T.int8(-1),
                       12,
                       placeholder_global[304],
                       80,
                       T.int8(-1),
                       T.int8(-1),
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       0,
                       0,
                       0,
                       dtype="handle"))
Beispiel #9
0
 def main(placeholder_5: T.Buffer[(8192, ), "int8"],
          ethosu_write_1: T.Buffer[(4096, ), "int8"]) -> None:
     # function attr dict
     T.func_attr({
         "from_legacy_te_schedule": True,
         "global_symbol": "main",
         "tir.noalias": True
     })
     buffer = T.buffer_decl([528], "uint8")
     buffer_2 = T.buffer_decl([336], "uint8")
     # body
     placeholder_d_global = T.allocate(
         [528],
         "uint8",
         "global",
         annotations={"disable_lower_builtin": True})
     placeholder_d_global_1 = T.allocate(
         [336],
         "uint8",
         "global",
         annotations={"disable_lower_builtin": True})
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer[0],
                       528,
                       placeholder_d_global[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_2[0],
                       336,
                       placeholder_d_global_1[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       32,
                       16,
                       0,
                       16,
                       placeholder_5[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       512,
                       32,
                       1,
                       "int8",
                       16,
                       16,
                       10,
                       16,
                       0,
                       16,
                       ethosu_write_1[0],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       256,
                       16,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       placeholder_d_global[0],
                       416,
                       T.int8(-1),
                       T.int8(-1),
                       12,
                       placeholder_d_global[416],
                       112,
                       T.int8(-1),
                       T.int8(-1),
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       0,
                       0,
                       0,
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       32,
                       16,
                       0,
                       16,
                       placeholder_5[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       512,
                       32,
                       1,
                       "int8",
                       16,
                       16,
                       6,
                       16,
                       0,
                       16,
                       ethosu_write_1[10],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       256,
                       16,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       placeholder_d_global_1[0],
                       272,
                       T.int8(-1),
                       T.int8(-1),
                       12,
                       placeholder_d_global_1[272],
                       64,
                       T.int8(-1),
                       T.int8(-1),
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       0,
                       0,
                       0,
                       dtype="handle"))
Beispiel #10
0
 def main(placeholder: T.Buffer[(1, 16, 16, 32), "int8"],
          ethosu_write: T.Buffer[(1, 16, 16, 8), "int8"]) -> None:
     # function attr dict
     T.func_attr({
         "from_legacy_te_schedule": True,
         "global_symbol": "main",
         "tir.noalias": True
     })
     buffer = T.buffer_var("uint8", "")
     buffer_1 = T.buffer_var("uint8", "")
     buffer_2 = T.buffer_var("uint8", "")
     buffer_3 = T.buffer_var("uint8", "")
     buffer_4 = T.buffer_var("uint8", "")
     buffer_5 = T.buffer_var("uint8", "")
     buffer_6 = T.buffer_var("uint8", "")
     buffer_7 = T.buffer_var("uint8", "")
     buffer_8 = T.buffer_var("uint8", "")
     buffer_9 = T.buffer_var("uint8", "")
     # body
     ethosu_write_1 = T.allocate(
         [4096],
         "int8",
         "global",
         annotations={"disable_lower_builtin": True})
     placeholder_global = T.allocate(
         [80],
         "uint8",
         "global",
         annotations={"disable_lower_builtin": True})
     placeholder_d_global = T.allocate(
         [32],
         "uint8",
         "global",
         annotations={"disable_lower_builtin": True})
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       32,
                       16,
                       0,
                       16,
                       T.load("int8", placeholder.data, 0),
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       512,
                       32,
                       1,
                       "int8",
                       16,
                       16,
                       16,
                       16,
                       0,
                       16,
                       T.load("int8", ethosu_write_1, 0),
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       256,
                       16,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       T.load("uint8", buffer, 0),
                       592,
                       12,
                       T.load("uint8", buffer_1, 0),
                       160,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       T.load("uint8", buffer_2, 0),
                       80,
                       T.load("uint8", placeholder_global, 0),
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       T.load("uint8", buffer_3, 0),
                       32,
                       T.load("uint8", placeholder_d_global, 0),
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       16,
                       16,
                       0,
                       16,
                       T.load("int8", ethosu_write_1, 0),
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       256,
                       16,
                       1,
                       "int8",
                       16,
                       16,
                       2,
                       16,
                       0,
                       16,
                       T.load("int8", ethosu_write.data, 0),
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       128,
                       8,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       T.load("uint8", placeholder_global, 0),
                       80,
                       12,
                       T.load("uint8", placeholder_d_global, 0),
                       32,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       T.load("uint8", buffer_4, 0),
                       80,
                       T.load("uint8", placeholder_global, 0),
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       T.load("uint8", buffer_5, 0),
                       32,
                       T.load("uint8", placeholder_d_global, 0),
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       16,
                       16,
                       0,
                       16,
                       T.load("int8", ethosu_write_1, 0),
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       256,
                       16,
                       1,
                       "int8",
                       16,
                       16,
                       2,
                       16,
                       0,
                       16,
                       T.load("int8", ethosu_write.data, 2),
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       128,
                       8,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       T.load("uint8", placeholder_global, 0),
                       80,
                       12,
                       T.load("uint8", placeholder_d_global, 0),
                       32,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       T.load("uint8", buffer_6, 0),
                       80,
                       T.load("uint8", placeholder_global, 0),
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       T.load("uint8", buffer_7, 0),
                       32,
                       T.load("uint8", placeholder_d_global, 0),
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       16,
                       16,
                       0,
                       16,
                       T.load("int8", ethosu_write_1, 0),
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       256,
                       16,
                       1,
                       "int8",
                       16,
                       16,
                       2,
                       16,
                       0,
                       16,
                       T.load("int8", ethosu_write.data, 4),
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       128,
                       8,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       T.load("uint8", placeholder_global, 0),
                       80,
                       12,
                       T.load("uint8", placeholder_d_global, 0),
                       32,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       T.load("uint8", buffer_8, 0),
                       80,
                       T.load("uint8", placeholder_global, 0),
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       T.load("uint8", buffer_9, 0),
                       32,
                       T.load("uint8", placeholder_d_global, 0),
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       16,
                       16,
                       0,
                       16,
                       T.load("int8", ethosu_write_1, 0),
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       256,
                       16,
                       1,
                       "int8",
                       16,
                       16,
                       2,
                       16,
                       0,
                       16,
                       T.load("int8", ethosu_write.data, 6),
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       128,
                       8,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       T.load("uint8", placeholder_global, 0),
                       80,
                       12,
                       T.load("uint8", placeholder_d_global, 0),
                       32,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
Beispiel #11
0
 def main(placeholder_5: T.Buffer[(8192, ), "int8"],
          ethosu_write_1: T.Buffer[(4096, ), "int8"]) -> None:
     # function attr dict
     T.func_attr({
         "from_legacy_te_schedule": True,
         "global_symbol": "main",
         "tir.noalias": True
     })
     buffer = T.buffer_decl([416], "uint8")
     buffer_1 = T.buffer_decl([112], "uint8")
     buffer_2 = T.buffer_decl([272], "uint8")
     buffer_3 = T.buffer_decl([64], "uint8")
     T.preflattened_buffer(placeholder_5, [1, 16, 16, 32],
                           dtype="int8",
                           data=placeholder_5.data)
     T.preflattened_buffer(ethosu_write_1, [1, 16, 16, 16],
                           dtype="int8",
                           data=ethosu_write_1.data)
     # body
     placeholder_global_unrolled_iter_0 = T.allocate(
         [416],
         "uint8",
         "global",
         annotations={"disable_lower_builtin": True})
     placeholder_global_unrolled_iter_1 = T.buffer_decl(
         [272], "uint8", data=placeholder_global_unrolled_iter_0.data)
     placeholder_d_global_unrolled_iter_0 = T.allocate(
         [112],
         "uint8",
         "global",
         annotations={"disable_lower_builtin": True})
     placeholder_d_global_unrolled_iter_1 = T.buffer_decl(
         [64],
         dtype="uint8",
         data=placeholder_d_global_unrolled_iter_0.data)
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer[0],
                       416,
                       placeholder_global_unrolled_iter_0[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_1[0],
                       112,
                       placeholder_d_global_unrolled_iter_0[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       32,
                       16,
                       0,
                       16,
                       placeholder_5[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       512,
                       32,
                       1,
                       "int8",
                       16,
                       16,
                       10,
                       16,
                       0,
                       16,
                       ethosu_write_1[0],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       256,
                       16,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       placeholder_global_unrolled_iter_0[0],
                       416,
                       12,
                       placeholder_d_global_unrolled_iter_0[0],
                       112,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_2[0],
                       272,
                       placeholder_global_unrolled_iter_1[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_3[0],
                       64,
                       placeholder_d_global_unrolled_iter_1[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       32,
                       16,
                       0,
                       16,
                       placeholder_5[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       512,
                       32,
                       1,
                       "int8",
                       16,
                       16,
                       6,
                       16,
                       0,
                       16,
                       ethosu_write_1[10],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       256,
                       16,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       placeholder_global_unrolled_iter_1[0],
                       272,
                       12,
                       placeholder_d_global_unrolled_iter_1[0],
                       64,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
Beispiel #12
0
 def main(placeholder: T.Buffer[(8192, ), "int8"],
          ethosu_write: T.Buffer[(2048, ), "int8"]) -> None:
     # function attr dict
     T.func_attr({
         "from_legacy_te_schedule": True,
         "global_symbol": "main",
         "tir.noalias": True
     })
     buffer = T.buffer_decl([592], "uint8")
     buffer_1 = T.buffer_decl([160], "uint8")
     buffer_2 = T.buffer_decl([80], "uint8")
     buffer_3 = T.buffer_decl([32], "uint8")
     buffer_4 = T.buffer_decl([80], "uint8")
     buffer_5 = T.buffer_decl([32], "uint8")
     buffer_6 = T.buffer_decl([80], "uint8")
     buffer_7 = T.buffer_decl([32], "uint8")
     buffer_8 = T.buffer_decl([80], "uint8")
     buffer_9 = T.buffer_decl([32], "uint8")
     T.preflattened_buffer(placeholder, [1, 16, 16, 32],
                           "int8",
                           data=placeholder.data)
     T.preflattened_buffer(ethosu_write, [1, 16, 16, 8],
                           "int8",
                           data=ethosu_write.data)
     # body
     ethosu_write_1 = T.allocate(
         [4096],
         "int8",
         "global",
         annotations={"disable_lower_builtin": True})
     placeholder_global = T.allocate(
         [80],
         "uint8",
         "global",
         annotations={"disable_lower_builtin": True})
     placeholder_d_global = T.allocate(
         [32],
         "uint8",
         "global",
         annotations={"disable_lower_builtin": True})
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       32,
                       16,
                       0,
                       16,
                       placeholder[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       512,
                       32,
                       1,
                       "int8",
                       16,
                       16,
                       16,
                       16,
                       0,
                       16,
                       ethosu_write_1[0],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       256,
                       16,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       buffer[0],
                       592,
                       12,
                       buffer_1[0],
                       160,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_2[0],
                       80,
                       placeholder_global[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_3[0],
                       32,
                       placeholder_d_global[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       16,
                       16,
                       0,
                       16,
                       ethosu_write_1[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       256,
                       16,
                       1,
                       "int8",
                       16,
                       16,
                       2,
                       16,
                       0,
                       16,
                       ethosu_write[0],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       128,
                       8,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       placeholder_global[0],
                       80,
                       12,
                       placeholder_d_global[0],
                       32,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_4[0],
                       80,
                       placeholder_global[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_5[0],
                       32,
                       placeholder_d_global[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       16,
                       16,
                       0,
                       16,
                       ethosu_write_1[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       256,
                       16,
                       1,
                       "int8",
                       16,
                       16,
                       2,
                       16,
                       0,
                       16,
                       ethosu_write[2],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       128,
                       8,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       placeholder_global[0],
                       80,
                       12,
                       placeholder_d_global[0],
                       32,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_6[0],
                       80,
                       placeholder_global[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_7[0],
                       32,
                       placeholder_d_global[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       16,
                       16,
                       0,
                       16,
                       ethosu_write_1[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       256,
                       16,
                       1,
                       "int8",
                       16,
                       16,
                       2,
                       16,
                       0,
                       16,
                       ethosu_write[4],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       128,
                       8,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       placeholder_global[0],
                       80,
                       12,
                       placeholder_d_global[0],
                       32,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_8[0],
                       80,
                       placeholder_global[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_copy",
                       buffer_9[0],
                       32,
                       placeholder_d_global[0],
                       dtype="handle"))
     T.evaluate(
         T.call_extern("ethosu_conv2d",
                       "int8",
                       16,
                       16,
                       16,
                       16,
                       0,
                       16,
                       ethosu_write_1[0],
                       0,
                       0,
                       0,
                       T.float32(0.5),
                       10,
                       "NHWC",
                       256,
                       16,
                       1,
                       "int8",
                       16,
                       16,
                       2,
                       16,
                       0,
                       16,
                       ethosu_write[6],
                       0,
                       0,
                       0,
                       T.float32(0.25),
                       14,
                       "NHWC",
                       128,
                       8,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       1,
                       placeholder_global[0],
                       80,
                       12,
                       placeholder_d_global[0],
                       32,
                       0,
                       0,
                       0,
                       0,
                       "NONE",
                       0,
                       0,
                       "TFL",
                       "NONE",
                       dtype="handle"))