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.

mesh_indexing.cpp 11 kB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299
  1. /**
  2. * \file dnn/test/naive/mesh_indexing.cpp
  3. * MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
  4. *
  5. * Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
  6. *
  7. * Unless required by applicable law or agreed to in writing,
  8. * software distributed under the License is distributed on an
  9. * "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10. */
  11. #include "megdnn/basic_types.h"
  12. #include "test/common/checker.h"
  13. #include "test/common/index.h"
  14. #include "test/common/mesh_indexing.h"
  15. #include "test/naive/fixture.h"
  16. using namespace megdnn;
  17. using namespace test;
  18. TEST_F(NAIVE, MESH_INDEXING) {
  19. SmallVector<size_t> init_axes;
  20. auto multi_axis_index_impl = [this,
  21. &init_axes](const TensorNDArray& tensors) {
  22. auto opr = handle()->create_operator<IndexingMultiAxisVec>();
  23. OprProxy<IndexingMultiAxisVec> proxy(init_axes);
  24. proxy.exec(opr.get(), tensors);
  25. };
  26. Checker<MeshIndexing> checker(handle());
  27. checker.set_extra_opr_impl(multi_axis_index_impl);
  28. size_t idx_size0, idx_size1;
  29. IndexRNG rng0{idx_size0, 2}, rng1{idx_size1, 3};
  30. checker.set_dtype(0, dtype::Float32())
  31. .set_dtype(1, dtype::Float32())
  32. .set_dtype(2, dtype::Int32())
  33. .set_dtype(3, dtype::Int32())
  34. .set_rng(2, &rng0)
  35. .set_rng(3, &rng1);
  36. idx_size0 = 23;
  37. init_axes = {0};
  38. checker.set_proxy({init_axes})
  39. .execs({{23}, {100}, {100}})
  40. .execs({{23, 5}, {100, 5}, {100}});
  41. idx_size0 = 3;
  42. init_axes = {1};
  43. checker.set_proxy(init_axes)
  44. .execs({{2, 3}, {2, 10}, {10}})
  45. .execs({{2, 3, 5}, {2, 50, 5}, {50}})
  46. .execs({{2, 3, 5, 7}, {2, 55, 5, 7}, {55}});
  47. }
  48. TEST_F(NAIVE, BATCHED_MESH_INDEXING) {
  49. SmallVector<size_t> init_axes;
  50. auto extra_impl = [this, &init_axes](const TensorNDArray& tensors) {
  51. auto opr = handle()->create_operator<MeshIndexing>();
  52. OprProxy<MeshIndexing> proxy(init_axes);
  53. size_t N = tensors[0].layout[0];
  54. for (size_t n = 0; n < N; ++n) {
  55. TensorNDArray new_tensors;
  56. for (size_t i = 0; i < tensors.size(); ++i) {
  57. auto&& tensor = tensors[i];
  58. TensorLayout layout = tensor.layout.remove_axis(0);
  59. if (i < 2) {
  60. layout.add_axis_cont_inplace(0);
  61. }
  62. void* ptr = static_cast<dt_byte*>(tensor.raw_ptr) +
  63. tensor.layout.stride[0] * n *
  64. tensor.layout.dtype.size();
  65. new_tensors.emplace_back(ptr, layout);
  66. }
  67. proxy.exec(opr.get(), new_tensors);
  68. }
  69. };
  70. Checker<BatchedMeshIndexing> checker(handle());
  71. checker.set_extra_opr_impl(extra_impl);
  72. size_t idx_size0, idx_size1;
  73. IndexRNG rng0{idx_size0, 2}, rng1{idx_size1, 3};
  74. checker.set_dtype(0, dtype::Float32())
  75. .set_dtype(1, dtype::Float32())
  76. .set_dtype(2, dtype::Int32())
  77. .set_dtype(3, dtype::Int32())
  78. .set_rng(2, &rng0)
  79. .set_rng(3, &rng1);
  80. idx_size0 = 5;
  81. init_axes = {1};
  82. checker.set_proxy({init_axes}).execs({{1, idx_size0}, {1, 3}, {1, 3}});
  83. idx_size0 = 23;
  84. idx_size1 = 17;
  85. init_axes = {1, 2};
  86. checker.set_proxy({init_axes})
  87. .execs({{7, idx_size0, idx_size1}, {7, 10, 20}, {7, 10}, {7, 20}})
  88. .execs({{7, idx_size0, idx_size1, 9},
  89. {7, 10, 20, 9},
  90. {7, 10},
  91. {7, 20}});
  92. init_axes = {2, 1};
  93. checker.set_proxy({init_axes})
  94. .execs({{8, idx_size1, idx_size0}, {8, 20, 10}, {8, 10}, {8, 20}})
  95. .execs({{8, idx_size1, idx_size0, 9},
  96. {8, 20, 10, 9},
  97. {8, 10},
  98. {8, 20}});
  99. idx_size0 = 5;
  100. init_axes = {1};
  101. TensorLayout index_layout{TensorShape{1, 3}, dtype::Int32()};
  102. index_layout = index_layout.broadcast({2, 3});
  103. checker.set_proxy({init_axes})
  104. .execl({TensorLayout{TensorShape{2, idx_size0}, dtype::Float32()},
  105. TensorLayout{TensorShape{2, 3}, dtype::Float32()},
  106. index_layout});
  107. }
  108. TEST_F(NAIVE, MESH_MODIFY_INCREMENT) {
  109. SmallVector<size_t> init_axes;
  110. auto multi_axis_index_impl = [this,
  111. &init_axes](const TensorNDArray& tensors) {
  112. auto opr = handle()->create_operator<IndexingIncrMultiAxisVec>();
  113. OprProxy<IndexingIncrMultiAxisVec> proxy(init_axes);
  114. proxy.exec(opr.get(), tensors);
  115. };
  116. Checker<IncrMeshIndexing> checker(handle());
  117. checker.set_extra_opr_impl(multi_axis_index_impl);
  118. size_t idx_size0, idx_size1;
  119. IndexRNG rng0{idx_size0, 2}, rng1{idx_size1, 3};
  120. checker.set_dtype(0, dtype::Float32())
  121. .set_dtype(1, dtype::Float32())
  122. .set_dtype(2, dtype::Int32())
  123. .set_dtype(3, dtype::Int32())
  124. .set_rng(2, &rng0)
  125. .set_rng(3, &rng1);
  126. idx_size0 = 23;
  127. init_axes = {0};
  128. checker.set_proxy({init_axes})
  129. .execs({{23}, {100}, {100}})
  130. .execs({{23, 5}, {100, 5}, {100}});
  131. idx_size0 = 3;
  132. init_axes = {1};
  133. checker.set_proxy(init_axes)
  134. .execs({{2, 3}, {2, 10}, {10}})
  135. .execs({{2, 3, 5}, {2, 50, 5}, {50}})
  136. .execs({{2, 3, 5, 7}, {2, 55, 5, 7}, {55}});
  137. }
  138. TEST_F(NAIVE, BATCHED_MESH_MODIFY_INCREMENT) {
  139. SmallVector<size_t> init_axes;
  140. auto extra_impl = [this, &init_axes](const TensorNDArray& tensors) {
  141. auto opr = handle()->create_operator<IncrMeshIndexing>();
  142. OprProxy<IncrMeshIndexing> proxy(init_axes);
  143. size_t N = tensors[0].layout[0];
  144. for (size_t n = 0; n < N; ++n) {
  145. TensorNDArray new_tensors;
  146. for (size_t i = 0; i < tensors.size(); ++i) {
  147. auto&& tensor = tensors[i];
  148. TensorLayout layout = tensor.layout.remove_axis(0);
  149. if (i < 2) {
  150. layout.add_axis_cont_inplace(0);
  151. }
  152. void* ptr =
  153. static_cast<dt_byte*>(tensor.raw_ptr) +
  154. tensor.layout.dtype.size(tensor.layout.stride[0] * n);
  155. new_tensors.emplace_back(ptr, layout);
  156. }
  157. proxy.exec(opr.get(), new_tensors);
  158. }
  159. };
  160. Checker<BatchedIncrMeshIndexing> checker(handle());
  161. checker.set_extra_opr_impl(extra_impl);
  162. size_t idx_size0, idx_size1;
  163. IndexRNG rng0{idx_size0, 2}, rng1{idx_size1, 3};
  164. checker.set_dtype(0, dtype::Float32())
  165. .set_dtype(1, dtype::Float32())
  166. .set_dtype(2, dtype::Int32())
  167. .set_dtype(3, dtype::Int32())
  168. .set_rng(2, &rng0)
  169. .set_rng(3, &rng1);
  170. idx_size0 = 5;
  171. init_axes = {1};
  172. checker.set_proxy({init_axes}).execs({{1, idx_size0}, {1, 3}, {1, 3}});
  173. idx_size0 = 23;
  174. idx_size1 = 17;
  175. init_axes = {1, 2};
  176. checker.set_proxy({init_axes})
  177. .execs({{7, idx_size0, idx_size1}, {7, 10, 20}, {7, 10}, {7, 20}})
  178. .execs({{7, idx_size0, idx_size1, 9},
  179. {7, 10, 20, 9},
  180. {7, 10},
  181. {7, 20}});
  182. init_axes = {2, 1};
  183. checker.set_proxy({init_axes})
  184. .execs({{8, idx_size1, idx_size0}, {8, 20, 10}, {8, 10}, {8, 20}})
  185. .execs({{8, idx_size1, idx_size0, 9},
  186. {8, 20, 10, 9},
  187. {8, 10},
  188. {8, 20}});
  189. }
  190. TEST_F(NAIVE, MESH_MODIFY_SETTING) {
  191. SmallVector<size_t> init_axes;
  192. auto extra_impl = [this, &init_axes](const TensorNDArray& tensors) {
  193. auto opr = handle()->create_operator<IncrMeshIndexing>();
  194. OprProxy<IncrMeshIndexing> proxy(init_axes);
  195. proxy.exec(opr.get(), tensors);
  196. };
  197. Checker<SetMeshIndexing> checker(handle());
  198. checker.set_extra_opr_impl(extra_impl);
  199. size_t idx_size0, idx_size1;
  200. mesh_indexing::NoReplacementIndexRNG rng0{idx_size0, 2}, rng1{idx_size1, 3};
  201. ConstValue zero_gen;
  202. checker.set_dtype(0, dtype::Float32())
  203. .set_dtype(1, dtype::Float32())
  204. .set_dtype(2, dtype::Int32())
  205. .set_dtype(3, dtype::Int32())
  206. .set_rng(2, &rng0)
  207. .set_rng(3, &rng1)
  208. .set_rng(0, &zero_gen);
  209. idx_size0 = 5;
  210. init_axes = {1};
  211. checker.set_proxy({init_axes}).execs({{1, idx_size0}, {1, 3}, {3}});
  212. idx_size0 = 23;
  213. idx_size1 = 20;
  214. init_axes = {1, 2};
  215. checker.set_proxy({init_axes})
  216. .execs({{7, idx_size0, idx_size1}, {7, 10, 20}, {10}, {20}})
  217. .execs({{7, idx_size0, idx_size1, 9}, {7, 10, 20, 9}, {10}, {20}});
  218. init_axes = {2, 1};
  219. checker.set_proxy({init_axes})
  220. .execs({{8, idx_size1, idx_size0}, {8, 20, 10}, {10}, {20}})
  221. .execs({{8, idx_size1, idx_size0, 9}, {8, 20, 10, 9}, {10}, {20}});
  222. }
  223. TEST_F(NAIVE, BATCHED_MESH_MODIFY_SETTING) {
  224. SmallVector<size_t> init_axes;
  225. auto extra_impl = [this, &init_axes](const TensorNDArray& tensors) {
  226. auto opr = handle()->create_operator<BatchedIncrMeshIndexing>();
  227. OprProxy<BatchedIncrMeshIndexing> proxy(init_axes);
  228. proxy.exec(opr.get(), tensors);
  229. };
  230. Checker<BatchedSetMeshIndexing> checker(handle());
  231. checker.set_extra_opr_impl(extra_impl);
  232. size_t idx_size0, idx_size1;
  233. mesh_indexing::NoReplacementIndexRNG rng0{idx_size0, 2}, rng1{idx_size1, 3};
  234. ConstValue zero_gen;
  235. checker.set_dtype(0, dtype::Float32())
  236. .set_dtype(1, dtype::Float32())
  237. .set_dtype(2, dtype::Int32())
  238. .set_dtype(3, dtype::Int32())
  239. .set_rng(2, &rng0)
  240. .set_rng(3, &rng1)
  241. .set_rng(0, &zero_gen);
  242. idx_size0 = 5;
  243. init_axes = {1};
  244. checker.set_proxy({init_axes}).execs({{1, idx_size0}, {1, 3}, {1, 3}});
  245. idx_size0 = 23;
  246. idx_size1 = 20;
  247. init_axes = {1, 2};
  248. checker.set_proxy({init_axes})
  249. .execs({{7, idx_size0, idx_size1}, {7, 10, 20}, {7, 10}, {7, 20}})
  250. .execs({{7, idx_size0, idx_size1, 9},
  251. {7, 10, 20, 9},
  252. {7, 10},
  253. {7, 20}});
  254. init_axes = {2, 1};
  255. checker.set_proxy({init_axes})
  256. .execs({{8, idx_size1, idx_size0}, {8, 20, 10}, {8, 10}, {8, 20}})
  257. .execs({{8, idx_size1, idx_size0, 9},
  258. {8, 20, 10, 9},
  259. {8, 10},
  260. {8, 20}});
  261. }

MegEngine 安装包中集成了使用 GPU 运行代码所需的 CUDA 环境,不用区分 CPU 和 GPU 版。 如果想要运行 GPU 程序,请确保机器本身配有 GPU 硬件设备并安装好驱动。 如果你想体验在云端 GPU 算力平台进行深度学习开发的感觉,欢迎访问 MegStudio 平台