diff --git "a/\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250\346\227\267\350\247\206\345\244\251\345\205\203MegEngine/4.\346\250\241\345\236\213\346\236\204\345\273\272\345\222\214\350\256\255\347\273\203\350\277\233\351\230\266 II\357\274\232\347\211\251\344\275\223\346\243\200\346\265\213.md" "b/\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250\346\227\267\350\247\206\345\244\251\345\205\203MegEngine/4.\346\250\241\345\236\213\346\236\204\345\273\272\345\222\214\350\256\255\347\273\203\350\277\233\351\230\266 II\357\274\232\347\211\251\344\275\223\346\243\200\346\265\213.md" new file mode 100644 index 0000000000000000000000000000000000000000..973047d1dc56c6700e35e39af23d922e922ccc99 --- /dev/null +++ "b/\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250\346\227\267\350\247\206\345\244\251\345\205\203MegEngine/4.\346\250\241\345\236\213\346\236\204\345\273\272\345\222\214\350\256\255\347\273\203\350\277\233\351\230\266 II\357\274\232\347\211\251\344\275\223\346\243\200\346\265\213.md" @@ -0,0 +1,36 @@ +## 主题 +模型构建和训练进阶 II:物体检测 +## 讲师 +王枫
+毕业于中科院计算所,旷视科技基础检测组算法研究员,曾获得ICDAR ArT文字检测任务冠军,在MegEngine中负责检测模型的复现和维护和Data部分的设计实现。 +## 概要 +本节课程中,我们将学习通用物体检测的方法和流程,并且我们将以Faster-RCNN为例讲述旷视天元MegEngine是如何实现通用物体检测的Pipeline的。其中包括数据准备,模型搭建,训练测试,还有节省显存的大杀器sublinear memory等内容。 + +## 资料 + +[4.模型构建和训练进阶 II:物体检测(anchor).ipynb](./notebooks/4.模型构建和训练进阶%20II:物体检测(anchor).ipynb)
+[4.模型构建和训练进阶 II:物体检测(nms).ipynb](./notebooks/4.模型构建和训练进阶%20II:物体检测(nms).ipynb)
+[4.模型构建和训练进阶 II:物体检测(transform_pipeline).ipynb](./notebooks/4.模型构建和训练进阶%20II:物体检测(transform_pipeline).ipynb)
+ +## 视频地址 + +https://www.bilibili.com/video/BV1hT4y1L7Z8 + +## 作业 + +了解MegEngine的hub的使用,上传一张图片,并且用hub中的Faster-RCNN 或者 RetinaNet 进行推理. + +### 如何提交 + +将运行成功的截图及个人信息发送到邮箱:mgesupport@megvii.com + +**邮件标题:** 天元入门第四次课程作业 + +**邮件内容** + +* 截图 +* 姓名: +* 学校(公司): +* 电话: +* 邮寄地址: + diff --git "a/\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250\346\227\267\350\247\206\345\244\251\345\205\203MegEngine/notebooks/4.\346\250\241\345\236\213\346\236\204\345\273\272\345\222\214\350\256\255\347\273\203\350\277\233\351\230\266 II\357\274\232\347\211\251\344\275\223\346\243\200\346\265\213(anchor).ipynb" "b/\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250\346\227\267\350\247\206\345\244\251\345\205\203MegEngine/notebooks/4.\346\250\241\345\236\213\346\236\204\345\273\272\345\222\214\350\256\255\347\273\203\350\277\233\351\230\266 II\357\274\232\347\211\251\344\275\223\346\243\200\346\265\213(anchor).ipynb" new file mode 100644 index 0000000000000000000000000000000000000000..1075534d53299a3aa026e61771b1c7fe5d881c48 --- /dev/null +++ "b/\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250\346\227\267\350\247\206\345\244\251\345\205\203MegEngine/notebooks/4.\346\250\241\345\236\213\346\236\204\345\273\272\345\222\214\350\256\255\347\273\203\350\277\233\351\230\266 II\357\274\232\347\211\251\344\275\223\346\243\200\346\265\213(anchor).ipynb" @@ -0,0 +1,210 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import numpy as np\n", + "\n", + "from megengine import Tensor, tensor\n", + "import megengine.functional as F\n", + "\n", + "\n", + "def meshgrid(x, y):\n", + " assert len(x.shape) == 1\n", + " assert len(y.shape) == 1\n", + " mesh_shape = (y.shape[0], x.shape[0])\n", + " mesh_x = x.broadcast(mesh_shape)\n", + " mesh_y = y.reshape(-1, 1).broadcast(mesh_shape)\n", + " return mesh_x, mesh_y\n", + "\n", + "\n", + "def create_anchor_grid(featmap_size, offsets, stride):\n", + " step_x, step_y = featmap_size\n", + " shift = offsets * stride\n", + "\n", + " grid_x = F.arange(shift, step_x * stride + shift, step=stride)\n", + " grid_y = F.arange(shift, step_y * stride + shift, step=stride)\n", + " grids_x, grids_y = meshgrid(grid_y, grid_x)\n", + " return grids_x.reshape(-1), grids_y.reshape(-1)\n", + "\n", + "\n", + "class AnchorGenerator:\n", + "\n", + " def __init__(\n", + " self,\n", + " anchor_scales: list = [[32], [64], [128], [256], [512]],\n", + " anchor_ratios: list = [[0.5, 1, 2]],\n", + " strides: list = [4, 8, 16, 32, 64],\n", + " offset: float = 0,\n", + " ):\n", + " super().__init__()\n", + " self.anchor_scales = np.array(anchor_scales, dtype=np.float32)\n", + " self.anchor_ratios = np.array(anchor_ratios, dtype=np.float32)\n", + " self.strides = strides\n", + " self.offset = offset\n", + " self.num_features = len(strides)\n", + "\n", + " self.base_anchors = self._different_level_anchors(anchor_scales, anchor_ratios)\n", + "\n", + " def _different_level_anchors(self, scales, ratios):\n", + " if len(scales) == 1:\n", + " scales *= self.num_features\n", + " assert len(scales) == self.num_features\n", + "\n", + " if len(ratios) == 1:\n", + " ratios *= self.num_features\n", + " assert len(ratios) == self.num_features\n", + " return [\n", + " tensor(self.generate_base_anchors(scale, ratio))\n", + " # self.generate_base_anchors(scale, ratio)\n", + " for scale, ratio in zip(scales, ratios)\n", + " ]\n", + "\n", + " def generate_base_anchors(self, scales, ratios):\n", + " base_anchors = []\n", + " areas = [s ** 2.0 for s in scales]\n", + " for area in areas:\n", + " for ratio in ratios:\n", + " w = math.sqrt(area / ratio)\n", + " h = ratio * w\n", + " # center-based anchor\n", + " x0, y0, x1, y1 = -w / 2.0, -h / 2.0, w / 2.0, h / 2.0\n", + " base_anchors.append([x0, y0, x1, y1])\n", + " return base_anchors\n", + "\n", + " def generate_anchors_by_features(self, sizes):\n", + " all_anchors = []\n", + " assert len(sizes) == self.num_features, (\n", + " \"input features expected {}, got {}\".format(self.num_features, len(sizes))\n", + " )\n", + " for size, stride, base_anchor in zip(sizes, self.strides, self.base_anchors):\n", + " grid_x, grid_y = create_anchor_grid(size, self.offset, stride)\n", + " # FIXME: If F.stack works, change to stack\n", + " grid_x, grid_y = grid_x.reshape(-1, 1), grid_y.reshape(-1, 1)\n", + " grids = F.concat([grid_x, grid_y, grid_x, grid_y], axis=1)\n", + " all_anchors.append(\n", + " (grids.reshape(-1, 1, 4) + base_anchor.reshape(1, -1, 4)).reshape(-1, 4)\n", + " )\n", + " return all_anchors\n", + " \n", + " def __call__(self, featmaps):\n", + " feat_sizes = [fmap.shape[-2:] for fmap in featmaps]\n", + " return self.generate_anchors_by_features(feat_sizes)\n", + "\n", + " @property\n", + " def anchor_dim(self):\n", + " return 4" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "shape of feature map: (1, 3, 400, 480)\n", + "shape of feature map: (1, 3, 200, 240)\n", + "shape of feature map: (1, 3, 100, 120)\n", + "shape of feature map: (1, 3, 50, 60)\n", + "shape of feature map: (1, 3, 25, 30)\n" + ] + } + ], + "source": [ + "from megengine.random import gaussian\n", + "shape = [1, 3, 25, 30]\n", + "shape_list = reversed([shape[:2] + [s * 2**i for s in shape[2:]] for i in range(5)])\n", + "feature_maps = [gaussian(shape) for shape in shape_list]\n", + "for featmap in feature_maps:\n", + " print(\"shape of feature map: {}\".format(featmap.shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "anchor shape: (576000, 4)\n", + "576000 = 400 * 480 * 3\n", + "anchor shape: (144000, 4)\n", + "144000 = 200 * 240 * 3\n", + "anchor shape: (36000, 4)\n", + "36000 = 100 * 120 * 3\n", + "anchor shape: (9000, 4)\n", + "9000 = 50 * 60 * 3\n", + "anchor shape: (2250, 4)\n", + "2250 = 25 * 30 * 3\n" + ] + } + ], + "source": [ + "anchor_generator = AnchorGenerator()\n", + "anchors_list = anchor_generator(feature_maps)\n", + "for anchors, fmap in zip(anchors_list, feature_maps):\n", + " print(\"anchor shape: {}\".format(anchors.shape))\n", + " print(\"{} = {} * {} * 3\".format(anchors.shape[0], *fmap.shape[2:]))" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tensor([1264. 1048. 1296. 1080.])\n", + "Tensor([ 608. 1032. 672. 1096.])\n", + "Tensor([1216. 992. 1344. 1120.])\n", + "Tensor([ 512. 928. 768. 1184.])\n", + "Tensor([1024. 768. 1536. 1280.])\n" + ] + } + ], + "source": [ + "for anchors in anchors_list:\n", + " print(anchors[anchors.shape[0] * 2 // 3 + 1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250\346\227\267\350\247\206\345\244\251\345\205\203MegEngine/notebooks/4.\346\250\241\345\236\213\346\236\204\345\273\272\345\222\214\350\256\255\347\273\203\350\277\233\351\230\266 II\357\274\232\347\211\251\344\275\223\346\243\200\346\265\213(nms).ipynb" "b/\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250\346\227\267\350\247\206\345\244\251\345\205\203MegEngine/notebooks/4.\346\250\241\345\236\213\346\236\204\345\273\272\345\222\214\350\256\255\347\273\203\350\277\233\351\230\266 II\357\274\232\347\211\251\344\275\223\346\243\200\346\265\213(nms).ipynb" new file mode 100644 index 0000000000000000000000000000000000000000..dafc3be25841981966a3fac614ca17a6bb287acb --- /dev/null +++ "b/\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250\346\227\267\350\247\206\345\244\251\345\205\203MegEngine/notebooks/4.\346\250\241\345\236\213\346\236\204\345\273\272\345\222\214\350\256\255\347\273\203\350\277\233\351\230\266 II\357\274\232\347\211\251\344\275\223\346\243\200\346\265\213(nms).ipynb" @@ -0,0 +1,101 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "\n", + "def cpu_nms(dets, thresh):\n", + " x1 = np.ascontiguousarray(dets[:, 0])\n", + " y1 = np.ascontiguousarray(dets[:, 1])\n", + " x2 = np.ascontiguousarray(dets[:, 2])\n", + " y2 = np.ascontiguousarray(dets[:, 3])\n", + "\n", + " areas = (x2 - x1) * (y2 - y1)\n", + " order = dets[:, 4].argsort()[::-1]\n", + " keep = list()\n", + "\n", + " while order.size > 0:\n", + " pick_ind = order[0]\n", + " keep.append(pick_ind)\n", + "\n", + " xx1 = np.maximum(x1[pick_ind], x1[order[1:]])\n", + " yy1 = np.maximum(y1[pick_ind], y1[order[1:]])\n", + " xx2 = np.minimum(x2[pick_ind], x2[order[1:]])\n", + " yy2 = np.minimum(y2[pick_ind], y2[order[1:]])\n", + "\n", + " inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)\n", + " iou = inter / (areas[pick_ind] + areas[order[1:]] - inter)\n", + "\n", + " order = order[np.where(iou <= thresh)[0] + 1]\n", + "\n", + " return keep" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "before nms:\n", + " [[ 11.5 12. 311.4 410.6 0.85]\n", + " [ 0.5 1. 300.4 400.5 0.97]\n", + " [ 200.5 300. 700.4 1000.6 0.65]\n", + " [ 250.5 310. 700.4 1000.6 0.72]]\n", + "after nms:\n", + " [[ 0.5 1. 300.4 400.5 0.97]\n", + " [ 250.5 310. 700.4 1000.6 0.72]]\n" + ] + } + ], + "source": [ + "dets = np.array([\n", + " [11.5, 12.0, 311.4, 410.6, 0.85],\n", + " [0.5, 1.0, 300.4, 400.5, 0.97],\n", + " [200.5, 300.0, 700.4, 1000.6, 0.65],\n", + " [250.5, 310.0, 700.4, 1000.6, 0.72],\n", + "])\n", + "np.set_printoptions(suppress=True)\n", + "print(\"before nms:\\n\", dets)\n", + "keep = cpu_nms(dets, 0.5)\n", + "print(\"after nms:\\n\", dets[keep])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250\346\227\267\350\247\206\345\244\251\345\205\203MegEngine/notebooks/4.\346\250\241\345\236\213\346\236\204\345\273\272\345\222\214\350\256\255\347\273\203\350\277\233\351\230\266 II\357\274\232\347\211\251\344\275\223\346\243\200\346\265\213(transform_pipeline).ipynb" "b/\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250\346\227\267\350\247\206\345\244\251\345\205\203MegEngine/notebooks/4.\346\250\241\345\236\213\346\236\204\345\273\272\345\222\214\350\256\255\347\273\203\350\277\233\351\230\266 II\357\274\232\347\211\251\344\275\223\346\243\200\346\265\213(transform_pipeline).ipynb" new file mode 100644 index 0000000000000000000000000000000000000000..deb23642b3e42a44b14d88f90306669446bae853 --- /dev/null +++ "b/\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250\346\227\267\350\247\206\345\244\251\345\205\203MegEngine/notebooks/4.\346\250\241\345\236\213\346\236\204\345\273\272\345\222\214\350\256\255\347\273\203\350\277\233\351\230\266 II\357\274\232\347\211\251\344\275\223\346\243\200\346\265\213(transform_pipeline).ipynb" @@ -0,0 +1,129 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "image shape: (612, 459, 3)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import cv2\n", + "img = cv2.imread(\"/home/wangfeng02/cat.jpg\")\n", + "print(\"image shape: {}\".format(img.shape))\n", + "plt.imshow(img)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "image shape before transform: (612, 459, 3)\n", + "ShortestEdgeResize\n", + "(1067, 800, 3)\n", + "RandomHorizontalFlip\n", + "(1067, 800, 3)\n", + "ToMode\n", + "(3, 1067, 800)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from megengine.data import transform as T\n", + "transforms=[\n", + " T.ShortestEdgeResize(\n", + " min_size=800,\n", + " max_size=1333,\n", + " sample_style=\"choice\",\n", + " ),\n", + " T.RandomHorizontalFlip(prob=0.5),\n", + " T.ToMode(\"CHW\"),\n", + "]\n", + "\n", + "transform_img = img\n", + "print(\"image shape before transform: {}\".format(img.shape))\n", + "for t in transforms:\n", + " print(t)\n", + " transform_img = t.apply(transform_img)\n", + " print(transform_img.shape)\n", + " if isinstance(t, T.RandomHorizontalFlip):\n", + " plt.imshow(transform_img)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}