diff --git a/CoordConv.ipynb b/CoordConv.ipynb index 2636986..78e1d2b 100644 --- a/CoordConv.ipynb +++ b/CoordConv.ipynb @@ -22,138 +22,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "class AddCoords(nn.Module):\n", - " def __init__(self, rank, with_r=False):\n", - " super(AddCoords, self).__init__()\n", - " self.rank = rank\n", - " self.with_r = with_r\n", - "\n", - " def forward(self, input_tensor):\n", - " \"\"\"\n", - " :param input_tensor: shape (N, C_in, H, W)\n", - " :return:\n", - " \"\"\"\n", - " if self.rank == 1:\n", - " batch_size_shape, channel_in_shape, dim_x = input_tensor.shape\n", - " xx_range = torch.arange(dim_x, dtype=torch.int32)\n", - " xx_channel = xx_range[None, None, :]\n", - "\n", - " xx_channel = xx_channel.float() / (dim_x - 1)\n", - " xx_channel = xx_channel * 2 - 1\n", - " xx_channel = xx_channel.repeat(batch_size_shape, 1, 1)\n", - "\n", - " if torch.cuda.is_available:\n", - " input_tensor = input_tensor.cuda()\n", - " xx_channel = xx_channel.cuda()\n", - " out = torch.cat([input_tensor, xx_channel], dim=1)\n", - "\n", - " if self.with_r:\n", - " rr = torch.sqrt(torch.pow(xx_channel - 0.5, 2))\n", - " out = torch.cat([out, rr], dim=1)\n", - " \n", - " elif self.rank == 2:\n", - " batch_size_shape, channel_in_shape, dim_y, dim_x = input_tensor.shape\n", - " xx_ones = torch.ones([1, 1, 1, dim_x], dtype=torch.int32)\n", - " yy_ones = torch.ones([1, 1, 1, dim_y], dtype=torch.int32)\n", - "\n", - " xx_range = torch.arange(dim_y, dtype=torch.int32)\n", - " yy_range = torch.arange(dim_x, dtype=torch.int32)\n", - " xx_range = xx_range[None, None, :, None]\n", - " yy_range = yy_range[None, None, :, None]\n", - " \n", - " xx_channel = torch.matmul(xx_range, xx_ones)\n", - " yy_channel = torch.matmul(yy_range, yy_ones)\n", - " \n", - " # transpose y\n", - " yy_channel = yy_channel.permute(0, 1, 3, 2)\n", - " \n", - " xx_channel = xx_channel.float() / (dim_y - 1)\n", - " yy_channel = yy_channel.float() / (dim_x - 1)\n", - "\n", - " xx_channel = xx_channel * 2 - 1\n", - " yy_channel = yy_channel * 2 - 1\n", - "\n", - " xx_channel = xx_channel.repeat(batch_size_shape, 1, 1, 1)\n", - " yy_channel = yy_channel.repeat(batch_size_shape, 1, 1, 1)\n", - "\n", - " if torch.cuda.is_available:\n", - " input_tensor = input_tensor.cuda()\n", - " xx_channel = xx_channel.cuda()\n", - " yy_channel = yy_channel.cuda()\n", - " out = torch.cat([input_tensor, xx_channel, yy_channel], dim=1)\n", - "\n", - " if self.with_r:\n", - " rr = torch.sqrt(torch.pow(xx_channel - 0.5, 2) + torch.pow(yy_channel - 0.5, 2))\n", - " out = torch.cat([out, rr], dim=1)\n", - "\n", - " elif self.rank == 3:\n", - " batch_size_shape, channel_in_shape, dim_z, dim_y, dim_x = input_tensor.shape\n", - " xx_ones = torch.ones([1, 1, 1, 1, dim_x], dtype=torch.int32)\n", - " yy_ones = torch.ones([1, 1, 1, 1, dim_y], dtype=torch.int32)\n", - " zz_ones = torch.ones([1, 1, 1, 1, dim_z], dtype=torch.int32)\n", - "\n", - " xy_range = torch.arange(dim_y, dtype=torch.int32)\n", - " xy_range = xy_range[None, None, None, :, None]\n", - "\n", - " yz_range = torch.arange(dim_z, dtype=torch.int32)\n", - " yz_range = yz_range[None, None, None, :, None]\n", - "\n", - " zx_range = torch.arange(dim_x, dtype=torch.int32)\n", - " zx_range = zx_range[None, None, None, :, None]\n", - "\n", - " xy_channel = torch.matmul(xy_range, xx_ones)\n", - " xx_channel = torch.cat([xy_channel + i for i in range(dim_z)], dim=2)\n", - "\n", - " yz_channel = torch.matmul(yz_range, yy_ones)\n", - " yz_channel = yz_channel.permute(0, 1, 3, 4, 2)\n", - " yy_channel = torch.cat([yz_channel + i for i in range(dim_x)], dim=4)\n", - "\n", - " zx_channel = torch.matmul(zx_range, zz_ones)\n", - " zx_channel = zx_channel.permute(0, 1, 4, 2, 3)\n", - " zz_channel = torch.cat([zx_channel + i for i in range(dim_y)], dim=3)\n", - "\n", - " if torch.cuda.is_available:\n", - " input_tensor = input_tensor.cuda()\n", - " xx_channel = xx_channel.cuda()\n", - " yy_channel = yy_channel.cuda()\n", - " zz_channel = zz_channel.cuda()\n", - " out = torch.cat([input_tensor, xx_channel, yy_channel, zz_channel], dim=1)\n", - "\n", - " if self.with_r:\n", - " rr = torch.sqrt(torch.pow(xx_channel - 0.5, 2) +\\\n", - " torch.pow(yy_channel - 0.5, 2) +\\\n", - " torch.pow(zz_channel - 0.5, 2))\n", - " out = torch.cat([out, rr], dim=1)\n", - " else:\n", - " raise NotImplementedError\n", - "\n", - " return out\n", - "\n", - "\n", - "class CoordConv2d(conv.Conv2d):\n", - " def __init__(self, in_channels, out_channels, kernel_size, stride=1,\n", - " padding=0, dilation=1, groups=1, bias=True, with_r=False):\n", - " super(CoordConv2d, self).__init__(in_channels, out_channels, kernel_size,\n", - " stride, padding, dilation, groups, bias)\n", - " self.rank = 2\n", - " self.addcoords = AddCoords(self.rank, with_r)\n", - " self.conv = nn.Conv2d(in_channels+self.rank+int(with_r), out_channels,\n", - " kernel_size, stride, padding, dilation, groups, bias)\n", - "\n", - " def forward(self, input_tensor):\n", - " \"\"\"\n", - " input_tensor_shape: (N, C_in,H,W)\n", - " output_tensor_shape: N,C_out,H_out,W_out）\n", - " :return: CoordConv2d Result\n", - " \"\"\"\n", - " out = self.addcoords(input_tensor)\n", - " out = self.conv(out)\n", - "\n", - " return out" + "from coordconv import *" ] }, { @@ -171,7 +44,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -295,22 +168,26 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAEICAYAAAB/KknhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAF9dJREFUeJzt3X/QHVV9x/H3hwQEITbhdyAg4NCqfyg6EXFi0SJailaYjrQ6WNOWTurUOlidkaBWa8cq2rFiZ1qdFNDUUoEiGoahKiD4YyyB8EuBCAEbICQmUBIBfxL49o89D715cu999tm7Z+/eZz+vmTvP/bH37Pfuvd9nz9lz9qwiAjPrlj3GHYCZNc+Jb9ZBTnyzDnLim3WQE9+sg5z4Zh3kxLdnSXqnpGsbXN8lkj7U1Prs/znxZyDpyZ7bM5J+0fP4zBHKvVHS22dYZh9J/yDpobTeeyS9R5KqrjcXSedJuiBj+TNur0laz7jNH3cAbRcR+03dl7QR+POIyL5XTMn9NWAB8AZgA3AC8CXgMOD9uWOwOSwifCt5AzYCJ097bh7wN8CPgUeBi4GF6bV9gUuAx4AdwFpgEfBp4Gngl8CTwKf7rOuNwM+BQ6c9fyKwEzgyPb4R+Ej6+zhwNbCoZ/nfTuvdAdwKLBvy+d4JXAf8U1r+/t7PCxyZyn8MuBdYnp4/Hfg18FT6PDcNKP944A7gCeDfgSuAD6XXDgL+C3gklb8GWJxe67u9gM8Bm9Lnvgk4oWddy4Db0ms/AT4x0zYp873MldvYA5ik24DEXwl8l2IvvDfwReAL6bWzgcuBfShqV68A9k2v3Qi8fci6zge+MeC1rT1JdyNwD/CC9I/m+8DfpteOAv4XOJmiWXdqSqxFA8p9Z0red1D8Q/trYGPP62uBzwDPAZamBJ1KmvOAC4Z8nr2BzcBfAnsCZ1L8A5tK/EOA09K2+o2U+Jf0vH+37ZXiXJTK+yDwELBneu024Ix0fwHwyjLbZKbvZa7c3MYf3V8AKyNic0T8Evgo8Eepqv4UxZ7sBRGxMyJujoiflSz3QGDLgNe2pNen/GtE3J/Kvhw4Lj2/HLgiIq6NiGci4mrgboqmwyD3RMS/RcTTwGrg+ZIWSjoWeCnwgYj4VUSsS6//ccnPcyLwq4j4l4h4KiIuBn4w9WJEbI2INRHxi4j4KfAJ4DXDCkxxbo+Ip4CPAwcAx6SXnwJ+U9IBEfFERKwdYZvMOU78EaTkPgK4WtIOSTso9jR7UPwILwS+DVwuaZOkj0uaV7L4R4HFA15bnF6f8pOe+z8Hpo5LPB94+1RsKb6lwGGSTu45SHnLkLJI5R0GPBIRv+h5/QHg8JKf5zCKanmvB6buSFog6SJJD0p6HPgmu/5z242kc9MBz58C2ylqFVPvWQ68BLhX0lpJv5ueH7hNSn6OOcEH90YQESHpYeAPIuKWAYt9GPiwpGOAbwB3URwHmOm0yGuBFZIOjYhnk1HSiRQ/7htKhPgQRfX73QNe32/A8/1sBg6StE9P8h8JPJzuz/R5tgBLpj13JDC13Vam118REVslnQB8r2fZXcqX9Hrg3RRV9vWAKI4dCCAi1lPUvOYBbwWukLSImbdJJ05X9R5/dJ8HzpN0BICkgyX9frp/sqQXS9qD4iDTToqDR1C004/pV2ByNUV7/SuSXihpvqRlFNXr8yPigSHvnbIaOEPS6yTNS92Dr5N0aIXPeR9F1fxjkp4j6eUUe9WLez7P0UO6Gr8D7J3GCsyX9DaKPfKUBRQ1jB2SDgSm9+9P314LKKrzjwB7AX9HsccHQNI7UjX/aeCnFAn9DDNvk5m+l7lh3AcZJunG4KP651B0tz1BkSAfSa8tT8//jKIK/Wlgj/Taa9Ky24FPDVjfc9N7HqY40rwBeB+gnmV2ORhFcYDu2p7Hyyj2nNuBbcCVwGED1jf9vXtTJMyS9PgoiiPv21Msf9az7KHAf6fXvj+g/BMo/nn0O6p/ZIrzSeBHFAcBd/a8d5ftRXFA70sU/1AfBt6TtvGr0/KXUTSHngB+CJxaZpuU+V7mwk3pw5pZh7iqb9ZBTnyzDnLim3XQSIkv6ZTUj3qfpJV1BWVmeVU+uJf6R+8FXk8xMONm4G0RcfeQ9/hIollmETHj2Zuj7PGPB+6LiB9HxK8pTkY5bYTyzKwhoyT+4RSjoKZsos/wTUkrJK2TtG6EdZlZjUYZstuvOrFbVT4iVgGrwFV9s7YYZY+/ieIElSlLKMZzm1nLjZL4NwPHSjpa0l4UJ0JcWU9YZpZT5ap+ROyU9FcUZ5zNAy6KiLtqi8zMsml0rL7b+Gb55e7OM7MJ5cQ36yAnvlkHOfHNOsiJb9ZBTnyzDpq4WXZ7ux9zX0JuWFdn1XXnjn9QzHWsq+r2qPsz1/G9TC+jye+zrnWPwnt8sw5y4pt1kEfuZZCjiTCo/BZeMbuyHFXg3M2MNm5/j9wzs76c+GYdNHFH9atq8mh37upfW46M51ZHNX3Q+6p+Z23ZNqPyHt+sg5z4Zh3kxDfroIlr41dt99XdNisbR+72f9nyZxPHuI6HNNl+rmtdk9q16j2+WQc58c06aCKq+lWr1b1yd4HVvd5xViF719cbRx3NlunvmdSTXGa77rY1CbzHN+sgJ75ZBznxzTrIZ+cNkXsijmFlVm0Tjut4SB3t7hwTfbSlbd3kEGmfnWdmfc2Y+JIukrRN0p09z+0v6RpJG9LfRXnDNLM6ldnjfxE4ZdpzK4HrIuJY4Lr0uHERscutbpIG3srGNazMYe8ru67ZlF/mPaOcBVd3GWXLG7bcoNfq+u2ULaPqZ8tlxsSPiO8Aj017+jRgdbq/Gji95rjMLKOqA3gOiYgtABGxRdLBgxaUtAJYUXE9ZpZB9pF7EbEKWAX1H9Wv4+SYHKPA6pjUIffR6EE9CLNZX1uOmI9TG+cFLKPqUf2tkhYDpL/b6gvJzHKrmvhXAsvT/eXAmnrCMbMmzDiAR9KXgdcCBwJbgY8AXwMuA44EHgTOiIjpBwD7ldXYAJ5xVvXrMM4rBnWhqt+m7z3DFOAzFtKZkXs5J5cYtq7ZjCTLmUhN/9AHfZbZjGCr+8y9OrZ9HTuUqjGW5ZF7ZtaXE9+sgyZiIo46NNntkuO1KspWbYepo9uvbPll5TghqGoX7KBt3JbfwCDe45t1kBPfrIOc+GYdNNFt/KpzxVfpWskdR9Xlqr6vyiQdsz3jL1cZVeUe+lyHpsZGeI9v1kFOfLMOmoiqfs7qT9NdK+PqvhpWZtOjF8u8Z/r76mjClF13jhGVueOfLe/xzTrIiW/WQRN9kk7TZ5WVPdpddZu2/ay4JqeIns26q8SRoyemLXySjpn15cQ36yAnvlkHTUQbf9LaWMNMwuWecqo6QUVb5I7RE3GYWTZOfLMOmoiRezmrfFVP0hnlMlF1lzlJxtntl3vUXR1leOSemWXjxDfrICe+WQdNXHfetPJGiqcuk9ANNRuTtr17tWXo7TgvUuLuPDPra8bEl3SEpOslrZd0l6Sz0/P7S7pG0ob0d1H+cM2sDmWunbcYWBwRt0paANwCnA78CfBYRJwnaSWwKCLOmaGsxs7OyzH3etnyql6Oqcq6qqoy534dl5aqQ9NnCY6riTDWqn5EbImIW9P9J4D1wOHAacDqtNhqin8GZjYBZjWAR9JRwMuAtcAhEbEFin8Okg4e8J4VwIrRwjSzOpU+qi9pP+DbwN9HxBWSdkTEwp7Xt0fE0Ha+q/rlyy+7rqpc1a+2vrlS1S+1x5e0J/AV4OKIuCI9vVXS4rS3XwxsqxTlCOqYNz7HPO91X4dtnNesyz2EuVfZz9mWbsXp6kja1gzZVRHJhcD6iPjHnpeuBJan+8uBNfWHZ2Y5lDmq/2rgu8APgWfS0x+gaOdfBhwJPAicERGPzVBWc6OFhqhaFR9XNa+tcdQdU1sHQuW++lHdylT1J2LkXq+6J8qcri0/tl5tSYg6Ej9HGVX+STY5ocb08htYt0fumdnunPhmHTQRE3FU0ZbLTo1zYoi625x1XD+gavdm7/tm05tTR9dqlW2XI8Y6eY9v1kFOfLMOcuKbddDEdef1aks3V1WTEP84xzxUuVZhG7fhTOqO3915ZtaXE9+sgya6ql9VW4fsVtGWbsu5ZJxDpOtYr6v6ZtaXE9+sg5z4Zh00EUN2657Rpqy2dhvVMXvOsDIGnUk2mzLGta3qaJ9XPeuz6hl44/gteY9v1kFOfLMOmoiqfh2TKeScD63p7p/cc+41OXfcuM54rOs7K9ssahvv8c06yIlv1kFzauTeJMx/Pq4592czB1yV8oetr8nqd9nPWdfvo43Ve4/cM7O+nPhmHeTEN+ugiejOK6vJNlaTl0hqS9txmCaPFQ2Te4TcsM+Z+7hPnbzHN+ugMtfO21vSTZLukHSXpI+m54+WtFbSBkmXStorf7hmVocy184TsG9EPKniqrnfA84G3gtcERGXSPo8cEdEfG6Gsmq9hFaf8gcuNwkjrNo+x1zVy0I12TXZtAzz5Y1cXi3deVF4Mj3cM90COAm4PD2/Gji9UpRm1rhSbXxJ8yTdDmwDrgHuB3ZExM60yCbg8AHvXSFpnaR1dQRsZqMrlfgR8XREHAcsAY4HXtRvsQHvXRURSyNiafUwzaxOs+rOi4gdkm4ATgAWSpqf9vpLgM0Z4ptab9/nq3bd5G5LVh0CW7b8Ji/pXHa9TXajVe0qqzumOsvJVd4gZY7qHyRpYbq/D3AysB64HnhLWmw5sCZXkGZWrzJ7/MXAaknzKP5RXBYRV0m6G7hE0seA24ALM8ZpZjWauLPzJmGet1454qiyDdrUBdYr9yW/29J12/CZoz47z8x258Q366CJO0lnXJczGrbupquebZuquZ+ynzN3T8a4tkdbm1ZTvMc36yAnvlkHOfHNOmjiuvPqlrstVnXu/6oxTcKEo200xz6Lu/PMbHdOfLMOmrjuvJomKhi5jLJmU37Oy07lKKPKyMCmmz5lyptNmbnn/m+K9/hmHeTEN+sgJ75ZB01cG38uqdrWa+NkHjnOrCs7YWfdw4Nno8pna8NZpd7jm3WQE9+sgyauql/H5Z1zXyK6rGFVvrrjaLoLqa1dplOqjljN0ZU4Dt7jm3WQE9+sgzp/ks5s5J4fri26cKLPOE/OamDdPknHzHbnxDfrICe+WQd1po1fpS2Z44yzOjR5rKHKukZZn43ObXwz66t04qdLZd8m6ar0+GhJayVtkHSppL3yhWlmdZrNHv9siotlTvkk8JmIOBbYDpxVZ2C9IuLZW9nlpt8kPXsrq/c9TVRdh8Vf9rNUWa4Ow7ZV1e+virJlDFtu2LafK0olvqQlwBuBC9JjAScBl6dFVgOn5wjQzOpXdo9/PvB+4Jn0+ABgR0TsTI83AYf3e6OkFZLWSVo3UqRmVpsZE1/Sm4BtEXFL79N9Fu1bD4qIVRGxNCKWVozRzGpW5uy8ZcCbJZ0K7A08j6IGsFDS/LTXXwJszhXkuCaXmG5Q11Zd897XEX/dXY51dBdWHa5axyQXVXShK3LGPX5EnBsRSyLiKOCtwLci4kzgeuAtabHlwJpsUZpZrUbpxz8HeK+k+yja/BfWE5KZ5dbJkXu9mr7sdpNnabXFpJ+tWMU4v1uP3DOzvpz4Zh00Z6v6Vataw6qlc6nKWuVz1tFsaWvzpup328bfhKv6ZtaXE9+sg5z4Zh00Z9v407VlUsdeOSbRaMsltHNq+lhDzklccnAb38z6cuKbddDEXUKrrDqurlrH+9pyhdbZlFH3JbvqHq3Y1hNx6vjNNdXM8h7frIOc+GYd5MQ366DOdOcNkmNobx3vG+d89m1rj46iyRjbsj3cnWdmfTnxzTpoznbn5dbkCK5hZdRxZt10bZnjsIpxzn0/bHsPWm5cvMc36yAnvlkHTVxVf9JOQql6xL9qGYOqm7l7HsYZx6D1li17+vva2tNTJ+/xzTrIiW/WQU58sw6aiDZ+3Wd6NTm6bTaqtk8HlVE1rirbsWw3Wu629XSDyqjj+FBVbZhw1Ht8sw4qtceXtBF4Anga2BkRSyXtD1wKHAVsBP4wIrbnCdPM6lTqJJ2U+Esj4tGe5z4FPBYR50laCSyKiHNmKKdSPWlcJ1pMl7PqmVtbrzPQohNbSsXRhmr6THKfpHMasDrdXw2cPkJZZtagsokfwDcl3SJpRXrukIjYApD+HtzvjZJWSFonad3o4ZpZHcoe1V8WEZslHQxcI+lHZVcQEauAVdDO8/HNuqhU4kfE5vR3m6SvAscDWyUtjogtkhYD23IFWXZu9DLvqbquYXJPhjFd7iGkZdc1aRNbtOV4QhvMWNWXtK+kBVP3gTcAdwJXAsvTYsuBNbmCNLN6ldnjHwJ8Nf2HnA/8R0R8XdLNwGWSzgIeBM7IF6aZ1amTc+65yrersqPp2nrGWd1djpPQZTeM59wzs76c+GYd5MQ366CJODuvbpPW5qxr3VXU3Q3YdPt5XNfmq8rXzjOzbJz4Zh000d15OSZ1qNskxDhOOUfnTTfpZxCW5e48M+vLiW/WQRNxVL/KfPO5r/Jadd67NlYbc1zmq2x5Ta5rnNoWs/f4Zh3kxDfrICe+WQdNRHdeW870akNMTawvp7a1dUfVxglH3Z1nZn058c06aCKq+pMs93x8OZojdfwm6pjMo2xMdWyDsidWDVP2kmINNA1d1Tez3TnxzTrIiW/WQRMxZLdXG4e8DjObIbtVLgc+CZdtrnuSyxzXtqt7WHHbr7/nPb5ZBznxzTpoIrrz2jg6apyanLevVx3Nltmst8l5+3JfP6DhkZ7uzjOz3ZVKfEkLJV0u6UeS1kt6laT9JV0jaUP6uyh3sGZWj1JVfUmrge9GxAWS9gKeC3wAeCwizpO0ElgUEefMUE7nRu6ZNa1MVX/GxJf0POAO4JjoWVjSPcBrey6TfUNE/NYMZTnxzTKrq41/DPAI8AVJt0m6IF0u+5CI2JJWtAU4uN+bJa2QtE7SulnEbmYZldnjLwVuBJZFxFpJnwUeB94dEQt7ltseEUPb+d7jm+VX1x5/E7ApItamx5cDLwe2pio+6e+2qoGaWbNmTPyI+AnwkKSp9vvrgLuBK4Hl6bnlwJosEZpZ7coe1T8OuADYC/gx8KcU/zQuA44EHgTOiIjHZijHVX2zzGo5ql8nJ75Zfh65Z2Z9OfHNOsiJb9ZBTnyzDnLim3WQE9+sg5qec+9R4AHgwHR/nNoQAziO6RzHrmYbx/PLLNRoP/6zK5XWRcTSxlfcshgch+MYVxyu6pt1kBPfrIPGlfirxrTeXm2IARzHdI5jV1niGEsb38zGy1V9sw5y4pt1UKOJL+kUSfdIui/NzNvUei+StE3SnT3PNT49uKQjJF2fpii/S9LZ44hF0t6SbpJ0R4rjo+n5oyWtTXFcmmZUzk7SvDSf41XjikPSRkk/lHT71PyQY/qNNDKVfWOJL2ke8M/A7wEvBt4m6cUNrf6LwCnTnlsJXBcRxwLXpce57QTeFxEvAk4A3pW2QdOx/Ao4KSJeChwHnCLpBOCTwGdSHNuBszLHMeVsYH3P43HF8TsRcVxPv/k4fiOfBb4eES8EXkqxXeqPIyIauQGvAr7R8/hc4NwG138UcGfP43uAxen+YuCepmLpiWEN8PpxxkJxjYRbgVdSjBCb3+/7yrj+JenHfBJwFaAxxbEROHDac41+L8DzgP8hHXTPGUeTVf3DgYd6Hm9Kz41LqenBc5F0FPAyYO04YknV69spJkm9Brgf2BERO9MiTX0/5wPvB55Jjw8YUxwBfFPSLZJWpOea/l5Gmsp+NppM/H7TAXWyL1HSfsBXgPdExOPjiCEino6I4yj2uMcDL+q3WM4YJL0J2BYRt/Q+3XQcybKIeDlFU/Rdkk5sYJ3TzaeYwfpzEfEy4Gdkal40mfibgCN6Hi8BNje4/unGMj24pD0pkv7iiLhinLEARMQO4AaKYw4LJU2duNXE97MMeLOkjcAlFNX988cQBxGxOf3dBnyV4p9h099LY1PZN5n4NwPHpiO2ewFvpZiie1wanx5ckoALgfUR8Y/jikXSQZIWpvv7ACdTHES6HnhLU3FExLkRsSQijqL4PXwrIs5sOg5J+0paMHUfeANwJw1/L9HkVPa5D5pMO0hxKnAvRXvygw2u98vAFuApiv+qZ1G0Ja8DNqS/+zcQx6spqq0/AG5Pt1ObjgV4CXBbiuNO4MPp+WOAm4D7gP8EntPgd/Ra4KpxxJHWd0e63TX12xzTb+Q4YF36br4GLMoRh4fsmnWQR+6ZdZAT36yDnPhmHeTEN+sgJ75ZBznxzTrIiW/WQf8HFNbbzwPczvoAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -402,36 +279,14 @@ "cell_type": "code", "execution_count": 7, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----------------------------------------------------------------\n", - " Layer (type) Output Shape Param #\n", - "================================================================\n", - " AddCoords-1 [-1, 5, 64, 64] 0\n", - " Conv2d-2 [-1, 32, 64, 64] 192\n", - " CoordConv2d-3 [-1, 32, 64, 64] 96\n", - " Conv2d-4 [-1, 64, 64, 64] 2,112\n", - " Conv2d-5 [-1, 64, 64, 64] 4,160\n", - " Conv2d-6 [-1, 1, 64, 64] 65\n", - " Conv2d-7 [-1, 1, 64, 64] 2\n", - "================================================================\n", - "Total params: 6,627\n", - "Trainable params: 6,627\n", - "Non-trainable params: 0\n", - "----------------------------------------------------------------\n" - ] - } - ], + "outputs": [], "source": [ "# model definition\n", "\n", "class Net(nn.Module):\n", " def __init__(self):\n", " super(Net, self).__init__()\n", - " self.coordconv = CoordConv2d(2, 32, 1, with_r=True)\n", + " self.coordconv = CoordConv2d(2, 32, 1, with_r=True, use_cuda=False)\n", " self.conv1 = nn.Conv2d(32, 64, 1)\n", " self.conv2 = nn.Conv2d(64, 64, 1)\n", " self.conv3 = nn.Conv2d(64, 1, 1)\n", @@ -446,10 +301,10 @@ " x = x.view(-1, 64*64)\n", " return x\n", "\n", - "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "device = torch.device(\"cpu\")\n", "net = Net().to(device)\n", "\n", - "summary(net, input_size=(2, 64, 64))" + "#summary(net, input_size=(2, 64, 64))" ] }, { @@ -525,16 +380,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Train Epoch: 1 [2508/2508 (100%)] Loss: 7.518124\n", - "Train Epoch: 2 [2508/2508 (100%)] Loss: 3.996769\n", - "Train Epoch: 3 [2508/2508 (100%)] Loss: 2.050044\n", - "Train Epoch: 4 [2508/2508 (100%)] Loss: 1.007079\n", - "Train Epoch: 5 [2508/2508 (100%)] Loss: 0.478236\n", - "Train Epoch: 6 [2508/2508 (100%)] Loss: 0.234409\n", - "Train Epoch: 7 [2508/2508 (100%)] Loss: 0.145100\n", - "Train Epoch: 8 [2508/2508 (100%)] Loss: 0.088965\n", - "Train Epoch: 9 [2508/2508 (100%)] Loss: 0.061546\n", - "Train Epoch: 10 [2508/2508 (100%)] Loss: 0.046458\n" + "Train Epoch: 1 [2508/2508 (100%)] Loss: 7.498067\n", + "Train Epoch: 2 [2508/2508 (100%)] Loss: 3.979326\n", + "Train Epoch: 3 [2508/2508 (100%)] Loss: 2.014220\n", + "Train Epoch: 4 [2508/2508 (100%)] Loss: 0.979962\n", + "Train Epoch: 5 [2508/2508 (100%)] Loss: 0.474519\n", + "Train Epoch: 6 [2508/2508 (100%)] Loss: 0.241503\n", + "Train Epoch: 7 [2508/2508 (100%)] Loss: 0.138851\n", + "Train Epoch: 8 [2508/2508 (100%)] Loss: 0.089052\n", + "Train Epoch: 9 [2508/2508 (100%)] Loss: 0.064587\n", + "Train Epoch: 10 [2508/2508 (100%)] Loss: 0.047140\n" ] } ], @@ -545,7 +400,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -577,7 +432,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -585,18 +440,20 @@ "output_type": "stream", "text": [ "\n", - "Test set: Average loss: 0.0463, Accuracy: 628/628 (100%)\n", + "Test set: Average loss: 0.0487, Accuracy: 628/628 (100%)\n", "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -628,7 +485,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.5" + "version": "3.7.5" } }, "nbformat": 4, diff --git a/coordconv.py b/coordconv.py index 6d21570..777ab79 100644 --- a/coordconv.py +++ b/coordconv.py @@ -4,10 +4,11 @@ import torch.nn.modules.conv as conv class AddCoords(nn.Module): - def __init__(self, rank, with_r=False): + def __init__(self, rank, with_r=False, use_cuda=True): super(AddCoords, self).__init__() self.rank = rank self.with_r = with_r + self.use_cuda = use_cuda def forward(self, input_tensor): """ @@ -23,7 +24,7 @@ class AddCoords(nn.Module): xx_channel = xx_channel * 2 - 1 xx_channel = xx_channel.repeat(batch_size_shape, 1, 1) - if torch.cuda.is_available: + if torch.cuda.is_available and self.use_cuda: input_tensor = input_tensor.cuda() xx_channel = xx_channel.cuda() out = torch.cat([input_tensor, xx_channel], dim=1) @@ -57,7 +58,7 @@ class AddCoords(nn.Module): xx_channel = xx_channel.repeat(batch_size_shape, 1, 1, 1) yy_channel = yy_channel.repeat(batch_size_shape, 1, 1, 1) - if torch.cuda.is_available: + if torch.cuda.is_available and self.use_cuda: input_tensor = input_tensor.cuda() xx_channel = xx_channel.cuda() yy_channel = yy_channel.cuda() @@ -93,7 +94,7 @@ class AddCoords(nn.Module): zx_channel = zx_channel.permute(0, 1, 4, 2, 3) zz_channel = torch.cat([zx_channel + i for i in range(dim_y)], dim=3) - if torch.cuda.is_available: + if torch.cuda.is_available and self.use_cuda: input_tensor = input_tensor.cuda() xx_channel = xx_channel.cuda() yy_channel = yy_channel.cuda() @@ -113,11 +114,11 @@ class AddCoords(nn.Module): class CoordConv1d(conv.Conv1d): def __init__(self, in_channels, out_channels, kernel_size, stride=1, - padding=0, dilation=1, groups=1, bias=True, with_r=False): + padding=0, dilation=1, groups=1, bias=True, with_r=False, use_cuda=True): super(CoordConv1d, self).__init__(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias) self.rank = 1 - self.addcoords = AddCoords(self.rank, with_r) + self.addcoords = AddCoords(self.rank, with_r, use_cuda=use_cuda) self.conv = nn.Conv1d(in_channels + self.rank + int(with_r), out_channels, kernel_size, stride, padding, dilation, groups, bias) @@ -135,11 +136,11 @@ class CoordConv1d(conv.Conv1d): class CoordConv2d(conv.Conv2d): def __init__(self, in_channels, out_channels, kernel_size, stride=1, - padding=0, dilation=1, groups=1, bias=True, with_r=False): + padding=0, dilation=1, groups=1, bias=True, with_r=False, use_cuda=True): super(CoordConv2d, self).__init__(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias) self.rank = 2 - self.addcoords = AddCoords(self.rank, with_r) + self.addcoords = AddCoords(self.rank, with_r, use_cuda=use_cuda) self.conv = nn.Conv2d(in_channels + self.rank + int(with_r), out_channels, kernel_size, stride, padding, dilation, groups, bias) @@ -157,11 +158,11 @@ class CoordConv2d(conv.Conv2d): class CoordConv3d(conv.Conv3d): def __init__(self, in_channels, out_channels, kernel_size, stride=1, - padding=0, dilation=1, groups=1, bias=True, with_r=False): + padding=0, dilation=1, groups=1, bias=True, with_r=False, use_cuda=True): super(CoordConv3d, self).__init__(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias) self.rank = 3 - self.addcoords = AddCoords(self.rank, with_r) + self.addcoords = AddCoords(self.rank, with_r, use_cuda=use_cuda) self.conv = nn.Conv3d(in_channels + self.rank + int(with_r), out_channels, kernel_size, stride, padding, dilation, groups, bias) @@ -174,4 +175,4 @@ class CoordConv3d(conv.Conv3d): out = self.addcoords(input_tensor) out = self.conv(out) - return out + return out \ No newline at end of file