└── roialign └── roialign.ipynb /roialign/roialign.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# RoI Align numba implementation" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "%matplotlib inline\n", 17 | "\n", 18 | "import torch\n", 19 | "from numba import cuda, float32\n", 20 | "import math\n", 21 | "import numpy as np\n", 22 | "import pandas as pd\n", 23 | "import os\n", 24 | "from matplotlib import pyplot as plt" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 2, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "# !conda install cudatoolkit -y" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "## Helper functions\n", 41 | "These functions are used to get data pointer from pytorch tensor and pass it to numba context." 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 3, 47 | "metadata": {}, 48 | "outputs": [], 49 | "source": [ 50 | "def _tensor_dtype(tensor):\n", 51 | " if isinstance(tensor, torch.cuda.FloatTensor):\n", 52 | " return np.dtype('float32')\n", 53 | " if isinstance(tensor, torch.cuda.ByteTensor):\n", 54 | " return np.dtype('uint8')\n", 55 | " if isinstance(tensor, torch.cuda.LongTensor):\n", 56 | " return np.dtype('int64')\n", 57 | " if isinstance(tensor, torch.cuda.CharTensor):\n", 58 | " return np.dtype('int8')\n", 59 | " raise Exception(f\"Unsupported tensor type {type(tensor)}\")\n", 60 | "\n", 61 | "\n", 62 | "if int(os.environ.get('NUMBA_ENABLE_CUDASIM', '0')) == 0:\n", 63 | " from numba.cuda.cudadrv.driver import MemoryPointer\n", 64 | " from numba.cuda.cudadrv.devicearray import DeviceNDArray\n", 65 | " import ctypes\n", 66 | "\n", 67 | " def numba_tensor(tensor):\n", 68 | " element_size = tensor.element_size()\n", 69 | " dtype = _tensor_dtype(tensor)\n", 70 | " strides = [i * element_size for i in tensor.stride()]\n", 71 | " stream = torch.cuda.current_stream().cuda_stream\n", 72 | " pointer = MemoryPointer(None, ctypes.c_ulong(tensor.data_ptr()), tensor.numel() * element_size)\n", 73 | " array = DeviceNDArray(tensor.size(), strides, dtype, gpu_data=pointer, stream=stream)\n", 74 | " return array\n", 75 | "else:\n", 76 | " def numba_tensor(tensor):\n", 77 | " dtype = _tensor_dtype(tensor)\n", 78 | " if dtype == np.dtype('int8'):\n", 79 | " return tensor.int().cpu().np().astype(dtype)\n", 80 | " return tensor.cpu().np()" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "metadata": {}, 86 | "source": [ 87 | "## Bilinear interpolation of features" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": 4, 93 | "metadata": {}, 94 | "outputs": [], 95 | "source": [ 96 | "@cuda.jit(device=True, inline=True)\n", 97 | "def bilinear_interpolate(features, roi_batch_ind, c, height, width, y, x):\n", 98 | " if y < -1.0 or y > height or x < -1.0 or x > width:\n", 99 | " return float32(0.0)\n", 100 | " if y < 0:\n", 101 | " y = 0\n", 102 | " if x < 0:\n", 103 | " x = 0\n", 104 | "\n", 105 | " y_low = int(y)\n", 106 | " x_low = int(x)\n", 107 | "\n", 108 | " if y_low >= height - 1:\n", 109 | " y_high = y_low = height - 1\n", 110 | " y = float32(y_low)\n", 111 | " else:\n", 112 | " y_high = y_low + 1\n", 113 | "\n", 114 | " if x_low >= width - 1:\n", 115 | " x_high = x_low = width - 1\n", 116 | " x = float32(x_low)\n", 117 | " else:\n", 118 | " x_high = x_low + 1\n", 119 | "\n", 120 | " ly = float32(y - y_low)\n", 121 | " lx = float32(x - x_low)\n", 122 | " hy = float32(1.0 - ly)\n", 123 | " hx = float32(1.0 - lx)\n", 124 | "\n", 125 | " v1 = features[roi_batch_ind, c, y_low, x_low]\n", 126 | " v2 = features[roi_batch_ind, c, y_low, x_high]\n", 127 | " v3 = features[roi_batch_ind, c, y_high, x_low]\n", 128 | " v4 = features[roi_batch_ind, c, y_high, x_high]\n", 129 | "\n", 130 | " w1 = hy * hx\n", 131 | " w2 = hy * lx\n", 132 | " w3 = ly * hx\n", 133 | " w4 = ly * lx\n", 134 | " val = w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4\n", 135 | "\n", 136 | " return val" 137 | ] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "metadata": {}, 142 | "source": [ 143 | "## RoI Align forward kernel" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": 5, 149 | "metadata": {}, 150 | "outputs": [], 151 | "source": [ 152 | "@cuda.jit\n", 153 | "def roi_align_forward_kernel(features, rois, spatial_scale, output):\n", 154 | " grid = cuda.grid(1)\n", 155 | " size = cuda.gridsize(1)\n", 156 | " nthreads = output.size\n", 157 | "\n", 158 | " channels = features.shape[1]\n", 159 | " height = features.shape[2]\n", 160 | " width = features.shape[3]\n", 161 | "\n", 162 | " aligned_height = output.shape[2]\n", 163 | " aligned_width = output.shape[3]\n", 164 | "\n", 165 | " for index in range(grid, nthreads, size):\n", 166 | " pw = index % aligned_width\n", 167 | " ph = (index // aligned_width) % aligned_height\n", 168 | " c = (index // aligned_width // aligned_height) % channels\n", 169 | " n = index // aligned_width // aligned_height // channels\n", 170 | "\n", 171 | " roi_batch_ind = int(rois[n, 0])\n", 172 | " roi_start_w = rois[n, 1] * spatial_scale\n", 173 | " roi_start_h = rois[n, 2] * spatial_scale\n", 174 | " roi_end_w = rois[n, 3] * spatial_scale\n", 175 | " roi_end_h = rois[n, 4] * spatial_scale\n", 176 | "\n", 177 | " roi_width = max(roi_end_w - roi_start_w, float32(1.0))\n", 178 | " roi_height = max(roi_end_h - roi_start_h, float32(1.0))\n", 179 | " bin_size_h = float32(roi_height) / float32(aligned_height)\n", 180 | " bin_size_w = float32(roi_width) / float32(aligned_width)\n", 181 | "\n", 182 | " # TODO: assuming sampling ratio = 2\n", 183 | " roi_bin_grid_h = 2\n", 184 | " roi_bin_grid_w = 2\n", 185 | "\n", 186 | " count = roi_bin_grid_h * roi_bin_grid_w\n", 187 | " output_val = float32(0.0)\n", 188 | "\n", 189 | " for iy in range(roi_bin_grid_h):\n", 190 | " y = roi_start_h + ph * bin_size_h + float32(iy + float32(0.5)) * bin_size_h / float32(roi_bin_grid_h)\n", 191 | " for ix in range(roi_bin_grid_w):\n", 192 | " x = roi_start_w + pw * bin_size_w + float32(ix + float32(0.5)) * bin_size_w / float32(roi_bin_grid_w)\n", 193 | " val = bilinear_interpolate(features, roi_batch_ind, c, height, width, y, x)\n", 194 | " output_val += val\n", 195 | " output[n, c, ph, pw] = output_val / count" 196 | ] 197 | }, 198 | { 199 | "cell_type": "markdown", 200 | "metadata": {}, 201 | "source": [ 202 | "## Gradient of bilinear interpolation" 203 | ] 204 | }, 205 | { 206 | "cell_type": "code", 207 | "execution_count": 6, 208 | "metadata": {}, 209 | "outputs": [], 210 | "source": [ 211 | "@cuda.jit(device=True, inline=True)\n", 212 | "def bilinear_interpolate_gradient(grad_output, grad_input, roi_batch_ind, c, height, width, y, x):\n", 213 | " if y < -1.0 or y > height or x < -1.0 or x > width:\n", 214 | " return\n", 215 | " if y < 0:\n", 216 | " y = 0\n", 217 | " if x < 0:\n", 218 | " x = 0\n", 219 | "\n", 220 | " y_low = int(y)\n", 221 | " x_low = int(x)\n", 222 | "\n", 223 | " if y_low >= height - 1:\n", 224 | " y_high = y_low = height - 1\n", 225 | " y = float32(y_low)\n", 226 | " else:\n", 227 | " y_high = y_low + 1\n", 228 | "\n", 229 | " if x_low >= width - 1:\n", 230 | " x_high = x_low = width - 1\n", 231 | " x = float32(x_low)\n", 232 | " else:\n", 233 | " x_high = x_low + 1\n", 234 | "\n", 235 | " ly = float32(y - y_low)\n", 236 | " lx = float32(x - x_low)\n", 237 | " hy = float32(1.0 - ly)\n", 238 | " hx = float32(1.0 - lx)\n", 239 | "\n", 240 | " w1 = hy * hx\n", 241 | " w2 = hy * lx\n", 242 | " w3 = ly * hx\n", 243 | " w4 = ly * lx\n", 244 | "\n", 245 | " cuda.atomic.add(grad_input, (roi_batch_ind, c, y_low, x_low), grad_output * w1)\n", 246 | " cuda.atomic.add(grad_input, (roi_batch_ind, c, y_low, x_high), grad_output * w2)\n", 247 | " cuda.atomic.add(grad_input, (roi_batch_ind, c, y_high, x_low), grad_output * w3)\n", 248 | " cuda.atomic.add(grad_input, (roi_batch_ind, c, y_high, x_high), grad_output * w4)" 249 | ] 250 | }, 251 | { 252 | "cell_type": "markdown", 253 | "metadata": {}, 254 | "source": [ 255 | "## RoI Align backward kernel" 256 | ] 257 | }, 258 | { 259 | "cell_type": "code", 260 | "execution_count": 7, 261 | "metadata": {}, 262 | "outputs": [], 263 | "source": [ 264 | "@cuda.jit\n", 265 | "def roi_align_backward_kernel(rois, spatial_scale, grad_output, grad_input):\n", 266 | " grid = cuda.grid(1)\n", 267 | " size = cuda.gridsize(1)\n", 268 | " nthreads = grad_output.size\n", 269 | "\n", 270 | " channels = grad_input.shape[1]\n", 271 | " height = grad_input.shape[2]\n", 272 | " width = grad_input.shape[3]\n", 273 | "\n", 274 | " aligned_height = grad_output.shape[2]\n", 275 | " aligned_width = grad_output.shape[3]\n", 276 | "\n", 277 | " for index in range(grid, nthreads, size):\n", 278 | " pw = index % aligned_width\n", 279 | " ph = (index // aligned_width) % aligned_height\n", 280 | " c = (index // aligned_width // aligned_height) % channels\n", 281 | " n = index // aligned_width // aligned_height // channels\n", 282 | "\n", 283 | " roi_batch_ind = int(rois[n, 0])\n", 284 | " roi_start_w = rois[n, 1] * spatial_scale\n", 285 | " roi_start_h = rois[n, 2] * spatial_scale\n", 286 | " roi_end_w = rois[n, 3] * spatial_scale\n", 287 | " roi_end_h = rois[n, 4] * spatial_scale\n", 288 | "\n", 289 | " roi_width = max(roi_end_w - roi_start_w, float32(1.0))\n", 290 | " roi_height = max(roi_end_h - roi_start_h, float32(1.0))\n", 291 | " bin_size_h = float32(roi_height) / float32(aligned_height)\n", 292 | " bin_size_w = float32(roi_width) / float32(aligned_width)\n", 293 | "\n", 294 | " # TODO: assuming sampling ratio = 2\n", 295 | " roi_bin_grid_h = 2\n", 296 | " roi_bin_grid_w = 2\n", 297 | "\n", 298 | " count = roi_bin_grid_h * roi_bin_grid_w\n", 299 | "\n", 300 | " for iy in range(roi_bin_grid_h):\n", 301 | " y = roi_start_h + ph * bin_size_h + float32(iy + float32(0.5)) * bin_size_h / float32(roi_bin_grid_h)\n", 302 | " for ix in range(roi_bin_grid_w):\n", 303 | " x = roi_start_w + pw * bin_size_w + float32(ix + float32(0.5)) * bin_size_w / float32(roi_bin_grid_w)\n", 304 | "\n", 305 | " grad = grad_output[n, c, ph, pw] / count\n", 306 | " bilinear_interpolate_gradient(grad, grad_input, roi_batch_ind, c, height, width, y, x)\n" 307 | ] 308 | }, 309 | { 310 | "cell_type": "markdown", 311 | "metadata": {}, 312 | "source": [ 313 | "## Pytorch function for RoI Align\n", 314 | "Run the kernels and wrap the code into pytorch function" 315 | ] 316 | }, 317 | { 318 | "cell_type": "code", 319 | "execution_count": 8, 320 | "metadata": {}, 321 | "outputs": [], 322 | "source": [ 323 | "def roi_align_forward(features, rois, spatial_scale, aligned_height, aligned_width):\n", 324 | " n_rois = rois.shape[0]\n", 325 | " channels = features.shape[1]\n", 326 | "\n", 327 | " threads_per_block = 512\n", 328 | " output = features.new(n_rois, channels, aligned_height, aligned_width)\n", 329 | " blocks = (output.numel() + threads_per_block - 1) // threads_per_block\n", 330 | "\n", 331 | " stream = torch.cuda.current_stream().cuda_stream\n", 332 | " roi_align_forward_kernel[blocks,\n", 333 | " threads_per_block,\n", 334 | " stream](numba_tensor(features), numba_tensor(rois), float32(spatial_scale), numba_tensor(output))\n", 335 | " return output\n", 336 | "\n", 337 | "\n", 338 | "def roi_align_backward(rois, spatial_scale, input_shape, grad_output: torch.cuda.FloatTensor):\n", 339 | " threads_per_block = 512\n", 340 | " grad_input = grad_output.data.new(*input_shape).fill_(0.0)\n", 341 | " blocks = (grad_output.numel() + threads_per_block - 1) // threads_per_block\n", 342 | "\n", 343 | " stream = torch.cuda.current_stream().cuda_stream\n", 344 | " roi_align_backward_kernel[blocks,\n", 345 | " threads_per_block,\n", 346 | " stream](numba_tensor(rois), float32(spatial_scale), numba_tensor(grad_output.data), numba_tensor(grad_input))\n", 347 | " return grad_input\n", 348 | "\n", 349 | "\n", 350 | "class RoIAlign(torch.autograd.Function):\n", 351 | " @staticmethod\n", 352 | " def forward(ctx, features, rois, spatial_scale, aligned_height, aligned_width):\n", 353 | " ctx.save_for_backward(rois)\n", 354 | " ctx.input_shape = features.shape\n", 355 | " ctx.spatial_scale = spatial_scale\n", 356 | " ctx.aligned_height = aligned_height\n", 357 | " ctx.aligned_width = aligned_width\n", 358 | "\n", 359 | " return roi_align_forward(features, rois, spatial_scale, aligned_height, aligned_width)\n", 360 | "\n", 361 | " @staticmethod\n", 362 | " def backward(ctx, grad_output):\n", 363 | " rois, = ctx.saved_tensors\n", 364 | " return torch.autograd.Variable(roi_align_backward(rois, ctx.spatial_scale, ctx.input_shape, grad_output)), None, None, None, None" 365 | ] 366 | }, 367 | { 368 | "cell_type": "markdown", 369 | "metadata": {}, 370 | "source": [ 371 | "# Simple visualizations" 372 | ] 373 | }, 374 | { 375 | "cell_type": "code", 376 | "execution_count": 9, 377 | "metadata": {}, 378 | "outputs": [ 379 | { 380 | "name": "stderr", 381 | "output_type": "stream", 382 | "text": [ 383 | "/home/marcin/github/fastai/fastai/fastai/datasets.py:164: YAMLLoadWarning: calling yaml.load() without Loader=... is deprecated, as the default Loader is unsafe. Please read https://msg.pyyaml.org/load for full details.\n", 384 | " with open(fpath, 'r') as yaml_file: return yaml.load(yaml_file)\n" 385 | ] 386 | } 387 | ], 388 | "source": [ 389 | "from fastai import *\n", 390 | "from fastai.vision import *\n", 391 | "\n", 392 | "path = untar_data(URLs.PETS)\n", 393 | "\n", 394 | "img_size = 224\n", 395 | "image = open_image(path / \"images\" / \"Ragdoll_47.jpg\").apply_tfms([], size=img_size)\n", 396 | "\n", 397 | "path_anno = path/'annotations'\n", 398 | "path_img = path/'images'\n", 399 | "\n", 400 | "fnames = get_image_files(path_img)\n", 401 | "\n", 402 | "np.random.seed(2)\n", 403 | "pat = r'/([^/]+)_\\d+.jpg$'\n", 404 | "\n", 405 | "data = ImageDataBunch\\\n", 406 | " .from_name_re(path_img, fnames, pat,\n", 407 | " size=img_size, bs=1)\n", 408 | "\n", 409 | "learn = cnn_learner(data, models.resnet34)" 410 | ] 411 | }, 412 | { 413 | "cell_type": "markdown", 414 | "metadata": {}, 415 | "source": [ 416 | "Load a cat image and draw some predefined bounding box." 417 | ] 418 | }, 419 | { 420 | "cell_type": "code", 421 | "execution_count": 10, 422 | "metadata": {}, 423 | "outputs": [ 424 | { 425 | "data": { 426 | "image/png": "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\n", 427 | "text/plain": [ 428 | "
" 429 | ] 430 | }, 431 | "metadata": { 432 | "needs_background": "light" 433 | }, 434 | "output_type": "display_data" 435 | } 436 | ], 437 | "source": [ 438 | "roi = np.array([0.075, 0.32, 0.6, 0.85])\n", 439 | "bbox = ImageBBox.create(*image.size, [roi * img_size], labels=[0], classes=[\"\"])\n", 440 | "figsize=(4,4)\n", 441 | "image.show(y=bbox, figsize=figsize)" 442 | ] 443 | }, 444 | { 445 | "cell_type": "code", 446 | "execution_count": 11, 447 | "metadata": {}, 448 | "outputs": [ 449 | { 450 | "data": { 451 | "text/plain": [ 452 | "torch.Size([1, 512, 7, 7])" 453 | ] 454 | }, 455 | "execution_count": 11, 456 | "metadata": {}, 457 | "output_type": "execute_result" 458 | } 459 | ], 460 | "source": [ 461 | "out = learn.model[0](image.data[None, ...].cuda())\n", 462 | "out.shape" 463 | ] 464 | }, 465 | { 466 | "cell_type": "markdown", 467 | "metadata": {}, 468 | "source": [ 469 | "Compute ResNet-34 feature maps (just before adaptive pooling)" 470 | ] 471 | }, 472 | { 473 | "cell_type": "code", 474 | "execution_count": 12, 475 | "metadata": {}, 476 | "outputs": [ 477 | { 478 | "data": { 479 | "image/png": "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\n", 480 | "text/plain": [ 481 | "
" 482 | ] 483 | }, 484 | "metadata": { 485 | "needs_background": "light" 486 | }, 487 | "output_type": "display_data" 488 | } 489 | ], 490 | "source": [ 491 | "_, axs = plt.subplots(1,4, figsize=(12,4))\n", 492 | "bbox = ImageBBox.create(*image.size, [roi * 7], labels=[0], classes=[\"\"])\n", 493 | "for channel, ax in enumerate(axs):\n", 494 | " Image(out[0, channel][None, ...].data.cpu()).show(ax=ax, y=bbox)" 495 | ] 496 | }, 497 | { 498 | "cell_type": "markdown", 499 | "metadata": {}, 500 | "source": [ 501 | "Run RoI Align" 502 | ] 503 | }, 504 | { 505 | "cell_type": "code", 506 | "execution_count": 13, 507 | "metadata": {}, 508 | "outputs": [ 509 | { 510 | "data": { 511 | "text/plain": [ 512 | "torch.Size([1, 512, 14, 14])" 513 | ] 514 | }, 515 | "execution_count": 13, 516 | "metadata": {}, 517 | "output_type": "execute_result" 518 | } 519 | ], 520 | "source": [ 521 | "top, left, bottom, right = roi\n", 522 | "rois = torch.FloatTensor([[0, left, top, right, bottom]]).cuda()\n", 523 | "aligned = RoIAlign.apply(out, rois, 7, 14, 14)\n", 524 | "aligned.shape" 525 | ] 526 | }, 527 | { 528 | "cell_type": "code", 529 | "execution_count": 14, 530 | "metadata": {}, 531 | "outputs": [ 532 | { 533 | "data": { 534 | "image/png": "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\n", 535 | "text/plain": [ 536 | "
" 537 | ] 538 | }, 539 | "metadata": { 540 | "needs_background": "light" 541 | }, 542 | "output_type": "display_data" 543 | } 544 | ], 545 | "source": [ 546 | "_, axs = plt.subplots(1,4, figsize=(12,4))\n", 547 | "for channel, ax in enumerate(axs):\n", 548 | " Image(aligned[0, channel][None, ...].data.cpu()).show(ax=ax)" 549 | ] 550 | } 551 | ], 552 | "metadata": { 553 | "kernelspec": { 554 | "display_name": "Python 3", 555 | "language": "python", 556 | "name": "python3" 557 | }, 558 | "language_info": { 559 | "codemirror_mode": { 560 | "name": "ipython", 561 | "version": 3 562 | }, 563 | "file_extension": ".py", 564 | "mimetype": "text/x-python", 565 | "name": "python", 566 | "nbconvert_exporter": "python", 567 | "pygments_lexer": "ipython3", 568 | "version": "3.7.1" 569 | } 570 | }, 571 | "nbformat": 4, 572 | "nbformat_minor": 2 573 | } 574 | --------------------------------------------------------------------------------