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": [
+ "