mirror of
https://github.com/wassname/CoordConv.git
synced 2026-09-11 11:52:18 +08:00
494 lines
45 KiB
Plaintext
494 lines
45 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 1,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"import os\n",
|
|
"import numpy as np\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"import torch\n",
|
|
"import torch.nn as nn\n",
|
|
"import torch.nn.modules.conv as conv\n",
|
|
"import torch.utils.data as utils\n",
|
|
"import torch.nn.functional as F\n",
|
|
"\n",
|
|
"from torch.autograd import Variable\n",
|
|
"from sklearn.model_selection import train_test_split\n",
|
|
"from torchsummary import summary"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"from coordconv import *"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Generate Data"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 3,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<torch._C.Generator at 0x7f3a8a9c39b0>"
|
|
]
|
|
},
|
|
"execution_count": 3,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"datatype = 'uniform'\n",
|
|
"assert datatype in ['uniform', 'quadrant']\n",
|
|
"\n",
|
|
"if not os.path.exists('data-uniform/'):\n",
|
|
" os.makedirs('data-uniform/')\n",
|
|
"\n",
|
|
"if not os.path.exists('data-quadrant/'):\n",
|
|
" os.makedirs('data-quadrant/')\n",
|
|
"\n",
|
|
"np.random.seed(0)\n",
|
|
"torch.manual_seed(0)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 4,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"onehots = np.pad(np.eye(3136, dtype='float32').reshape((3136, 56, 56, 1)),\n",
|
|
" ((0, 0), (4, 4), (4, 4), (0, 0)), mode=\"constant\")\n",
|
|
"onehots = onehots.transpose(0, 3, 1, 2)\n",
|
|
"\n",
|
|
"onehots_tensor = torch.from_numpy(onehots)\n",
|
|
"\n",
|
|
"conv_layer = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=(9,9), padding=4, stride=1)\n",
|
|
"w = torch.ones(1, 1, 9, 9)\n",
|
|
"conv_layer.weight.data = w\n",
|
|
"\n",
|
|
"images_tensor = conv_layer(onehots_tensor)\n",
|
|
"images = images_tensor.detach().numpy()\n",
|
|
"\n",
|
|
"if datatype == 'uniform':\n",
|
|
" # Create the uniform datasets\n",
|
|
" indices = np.arange(0, len(onehots), dtype='int32')\n",
|
|
" train, test = train_test_split(indices, test_size=0.2, random_state=0)\n",
|
|
"\n",
|
|
" train_onehot = onehots[train]\n",
|
|
" train_images = images[train]\n",
|
|
"\n",
|
|
" test_onehot = onehots[test]\n",
|
|
" test_images = images[test]\n",
|
|
"\n",
|
|
" np.save('data-uniform/train_onehot.npy', train_onehot)\n",
|
|
" np.save('data-uniform/train_images.npy', train_images)\n",
|
|
" np.save('data-uniform/test_onehot.npy', test_onehot)\n",
|
|
" np.save('data-uniform/test_images.npy', test_images)\n",
|
|
"else:\n",
|
|
" pos_quadrant = np.where(onehots == 1.0)\n",
|
|
"# print(onehots.shape)\n",
|
|
" X = pos_quadrant[2]\n",
|
|
" Y = pos_quadrant[3]\n",
|
|
" \n",
|
|
" train_set = []\n",
|
|
" test_set = []\n",
|
|
"\n",
|
|
" train_ids = []\n",
|
|
" test_ids = []\n",
|
|
"\n",
|
|
" for i, (x, y) in enumerate(zip(X, Y)):\n",
|
|
" if x > 32 and y > 32: # 4th quadrant\n",
|
|
" test_ids.append(i)\n",
|
|
" test_set.append([x, y])\n",
|
|
" else:\n",
|
|
" train_ids.append(i)\n",
|
|
" train_set.append([x, y])\n",
|
|
"\n",
|
|
" train_set = np.array(train_set)\n",
|
|
" test_set = np.array(test_set)\n",
|
|
" \n",
|
|
" train_set = train_set[:, :, None, None]\n",
|
|
" test_set = test_set[:, :, None, None]\n",
|
|
"\n",
|
|
" print(train_set.shape)\n",
|
|
" print(test_set.shape)\n",
|
|
"\n",
|
|
" train_onehot = onehots[train_ids]\n",
|
|
" test_onehot = onehots[test_ids]\n",
|
|
"\n",
|
|
" train_images = images[train_ids]\n",
|
|
" test_images = images[test_ids]\n",
|
|
"\n",
|
|
" print(train_onehot.shape, test_onehot.shape)\n",
|
|
" print(train_images.shape, test_images.shape)\n",
|
|
"\n",
|
|
" np.save('data-quadrant/train_set.npy', train_set)\n",
|
|
" np.save('data-quadrant/test_set.npy', test_set)\n",
|
|
" np.save('data-quadrant/train_onehot.npy', train_onehot)\n",
|
|
" np.save('data-quadrant/train_images.npy', train_images)\n",
|
|
" np.save('data-quadrant/test_onehot.npy', test_onehot)\n",
|
|
" np.save('data-quadrant/test_images.npy', test_images)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Load data numpy"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 5,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Train set : (2508, 2, 64, 64) 0.93650794 0.06349207\n",
|
|
"Test set : (628, 2, 64, 64) 0.93650794 0.06349207\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"image/png": "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\n",
|
|
"text/plain": [
|
|
"<Figure size 432x288 with 1 Axes>"
|
|
]
|
|
},
|
|
"metadata": {
|
|
"needs_background": "light"
|
|
},
|
|
"output_type": "display_data"
|
|
},
|
|
{
|
|
"data": {
|
|
"image/png": "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\n",
|
|
"text/plain": [
|
|
"<Figure size 432x288 with 1 Axes>"
|
|
]
|
|
},
|
|
"metadata": {
|
|
"needs_background": "light"
|
|
},
|
|
"output_type": "display_data"
|
|
}
|
|
],
|
|
"source": [
|
|
"if datatype == 'uniform':\n",
|
|
" # Load the one hot datasets\n",
|
|
" train_onehot = np.load('data-uniform/train_onehot.npy').astype('float32')\n",
|
|
" test_onehot = np.load('data-uniform/test_onehot.npy').astype('float32')\n",
|
|
"\n",
|
|
" # (N, C, H, W) <=== 数据格式\n",
|
|
" # make the train and test datasets\n",
|
|
" # train\n",
|
|
" pos_train = np.where(train_onehot == 1.0)\n",
|
|
" X_train = pos_train[2]\n",
|
|
" Y_train = pos_train[3]\n",
|
|
" train_set = np.zeros((len(X_train), 2, 1, 1), dtype='float32')\n",
|
|
" for i, (x, y) in enumerate(zip(X_train, Y_train)):\n",
|
|
" train_set[i, 0, 0, 0] = x\n",
|
|
" train_set[i, 1, 0, 0] = y\n",
|
|
"\n",
|
|
" # test\n",
|
|
" pos_test = np.where(test_onehot == 1.0)\n",
|
|
" X_test = pos_test[2]\n",
|
|
" Y_test = pos_test[3]\n",
|
|
" test_set = np.zeros((len(X_test), 2, 1, 1), dtype='float32')\n",
|
|
" for i, (x, y) in enumerate(zip(X_test, Y_test)):\n",
|
|
" test_set[i, 0, 0, 0] = x\n",
|
|
" test_set[i, 1, 0, 0] = y\n",
|
|
"\n",
|
|
" train_set = np.tile(train_set, [1, 1, 64, 64])\n",
|
|
" test_set = np.tile(test_set, [1, 1, 64, 64])\n",
|
|
"\n",
|
|
" # Normalize the datasets\n",
|
|
" train_set /= (64. - 1.) # 64x64 grid, 0-based index\n",
|
|
" test_set /= (64. - 1.) # 64x64 grid, 0-based index\n",
|
|
"\n",
|
|
" print('Train set : ', train_set.shape, train_set.max(), train_set.min())\n",
|
|
" print('Test set : ', test_set.shape, test_set.max(), test_set.min())\n",
|
|
"\n",
|
|
" # Visualize the datasets\n",
|
|
"\n",
|
|
" plt.imshow(np.sum(train_onehot, axis=0)[0, :, :], cmap='gray')\n",
|
|
" plt.title('Train One-hot dataset')\n",
|
|
" plt.show()\n",
|
|
" plt.imshow(np.sum(test_onehot, axis=0)[0, :, :], cmap='gray')\n",
|
|
" plt.title('Test One-hot dataset')\n",
|
|
" plt.show()\n",
|
|
"\n",
|
|
"else:\n",
|
|
" # Load the one hot datasets and the train / test set\n",
|
|
" train_set = np.load('data-quadrant/train_set.npy').astype('float32')\n",
|
|
" test_set = np.load('data-quadrant/test_set.npy').astype('float32')\n",
|
|
"\n",
|
|
" train_onehot = np.load('data-quadrant/train_onehot.npy').astype('float32')\n",
|
|
" test_onehot = np.load('data-quadrant/test_onehot.npy').astype('float32')\n",
|
|
"\n",
|
|
" train_set = np.tile(train_set, [1, 1, 64, 64])\n",
|
|
" test_set = np.tile(test_set, [1, 1, 64, 64])\n",
|
|
"\n",
|
|
" # Normalize datasets\n",
|
|
" train_set /= train_set.max()\n",
|
|
" test_set /= test_set.max()\n",
|
|
"\n",
|
|
" print('Train set : ', train_set.shape, train_set.max(), train_set.min())\n",
|
|
" print('Test set : ', test_set.shape, test_set.max(), test_set.min())\n",
|
|
"\n",
|
|
" # Visualize the datasets\n",
|
|
"\n",
|
|
" plt.imshow(np.sum(train_onehot, axis=0)[0, :, :], cmap='gray')\n",
|
|
" plt.title('Train One-hot dataset')\n",
|
|
" plt.show()\n",
|
|
" plt.imshow(np.sum(test_onehot, axis=0)[0, :, :], cmap='gray')\n",
|
|
" plt.title('Test One-hot dataset')\n",
|
|
" plt.show()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 6,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"# flatten the datasets\n",
|
|
"train_onehot = train_onehot.reshape((-1, 64 * 64)).astype('int64')\n",
|
|
"test_onehot = test_onehot.reshape((-1, 64 * 64)).astype('int64')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 7,
|
|
"metadata": {},
|
|
"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, 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",
|
|
" self.conv4 = nn.Conv2d( 1, 1, 1)\n",
|
|
"\n",
|
|
" def forward(self, x):\n",
|
|
" x = self.coordconv(x)\n",
|
|
" x = F.relu(self.conv1(x))\n",
|
|
" x = F.relu(self.conv2(x))\n",
|
|
" x = F.relu(self.conv3(x))\n",
|
|
" x = self.conv4(x)\n",
|
|
" x = x.view(-1, 64*64)\n",
|
|
" return x\n",
|
|
"\n",
|
|
"device = torch.device(\"cpu\")\n",
|
|
"net = Net().to(device)\n",
|
|
"\n",
|
|
"#summary(net, input_size=(2, 64, 64))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Make Datasets"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 8,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"train_tensor_x = torch.stack([torch.Tensor(i) for i in train_set])\n",
|
|
"train_tensor_y = torch.stack([torch.LongTensor(i) for i in train_onehot])\n",
|
|
"\n",
|
|
"train_dataset = utils.TensorDataset(train_tensor_x,train_tensor_y)\n",
|
|
"train_dataloader = utils.DataLoader(train_dataset, batch_size=32, shuffle=False)\n",
|
|
"\n",
|
|
"test_tensor_x = torch.stack([torch.Tensor(i) for i in test_set])\n",
|
|
"test_tensor_y = torch.stack([torch.LongTensor(i) for i in test_onehot])\n",
|
|
"\n",
|
|
"test_dataset = utils.TensorDataset(test_tensor_x,test_tensor_y)\n",
|
|
"test_dataloader = utils.DataLoader(test_dataset, batch_size=32, shuffle=False)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 9,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"optimizer = torch.optim.Adam(net.parameters(), lr=1e-3)\n",
|
|
"def cross_entropy_one_hot(input, target):\n",
|
|
" _, labels = target.max(dim=1)\n",
|
|
" return nn.CrossEntropyLoss()(input, labels)\n",
|
|
"criterion = cross_entropy_one_hot\n",
|
|
"epochs = 10"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 10,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"def train(epoch, net, train_dataloader, optimizer, criterion, device):\n",
|
|
" net.train()\n",
|
|
" iters = 0\n",
|
|
" for batch_idx, (data, target) in enumerate(train_dataloader):\n",
|
|
" data, target = Variable(data), Variable(target)\n",
|
|
" data, target = data.to(device), target.to(device)\n",
|
|
" optimizer.zero_grad()\n",
|
|
" output = net(data)\n",
|
|
" loss = criterion(output, target)\n",
|
|
" loss.backward()\n",
|
|
" optimizer.step()\n",
|
|
" iters += len(data)\n",
|
|
" print('Train Epoch: {} [{}/{} ({:.0f}%)] Loss: {:.6f}'.format(\n",
|
|
" epoch, iters, len(train_dataloader.dataset),\n",
|
|
" 100. * (batch_idx + 1) / len(train_dataloader), loss.data.item()), end='\\r', flush=True)\n",
|
|
" print(\"\")"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 11,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"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"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"for epoch in range(1, epochs + 1):\n",
|
|
" train(epoch, net, train_dataloader, optimizer, criterion, device)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 13,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"def test(net, test_loader, optimizer, criterion, device):\n",
|
|
" net.eval()\n",
|
|
" test_loss = 0\n",
|
|
" correct = 0\n",
|
|
" pred_logits = torch.tensor([])\n",
|
|
" for data, target in test_loader:\n",
|
|
" with torch.no_grad():\n",
|
|
" data, target = data.to(device), target.to(device)\n",
|
|
" output = net(data)\n",
|
|
" logits = F.softmax(output, dim=1)\n",
|
|
" pred_logits = torch.cat((pred_logits, logits.cpu()), dim=0)\n",
|
|
" test_loss += criterion(output, target).item()\n",
|
|
" _, pred = output.max(1, keepdim=True)\n",
|
|
" _, label = target.max(dim=1)\n",
|
|
" correct += pred.eq(label.view_as(pred)).sum().item()\n",
|
|
"\n",
|
|
" test_loss = test_loss\n",
|
|
" test_loss /= len(test_loader) # loss function already averages over batch size\n",
|
|
" print('\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
|
|
" test_loss, correct, len(test_loader.dataset),\n",
|
|
" 100. * correct / len(test_loader.dataset)))\n",
|
|
" pred_logits = torch.sum(pred_logits, dim=0)\n",
|
|
" plt.imshow(pred_logits.detach().numpy().reshape(-1,64), cmap='gray')\n",
|
|
" plt.title('Predictions One-hot dataset')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 14,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n",
|
|
"Test set: Average loss: 0.0487, Accuracy: 628/628 (100%)\n",
|
|
"\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"image/png": "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\n",
|
|
"text/plain": [
|
|
"<Figure size 432x288 with 1 Axes>"
|
|
]
|
|
},
|
|
"metadata": {
|
|
"needs_background": "light"
|
|
},
|
|
"output_type": "display_data"
|
|
}
|
|
],
|
|
"source": [
|
|
"test(net, test_dataloader, optimizer, criterion, device)"
|
|
]
|
|
},
|
|
{
|
|
"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.7.5"
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 2
|
|
}
|