File size: 59,696 Bytes
d5bfab8 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 |
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "929a1d7b-51a8-44ed-ab3b-8b2a2baa31dc",
"metadata": {},
"outputs": [],
"source": [
"import arc_json_model as ajm\n",
"from visualize import ajm_image_show\n",
"\n",
"ajm.Image.show = ajm_image_show"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "bcc018d5-5c3e-4acc-a9fd-e670d8a21c27",
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"import numpy as np\n",
"from torchvision import datasets\n",
"import torchvision.transforms as transforms\n",
"from torchsummary import summary\n",
"from tqdm import tqdm\n",
"\n",
"\n",
"device = torch.device(\"mps\")\n",
"#device = torch.device(\"cuda\")\n",
"#device = torch.device(\"cpu\")\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "fbaa81fe-7682-4cb3-9f57-fe94d5dd4fa4",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 500x500 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"filename = 'testdata/af902bf9.json'\n",
"#filename = 'testdata/62c24649.json'\n",
"#filename = 'testdata/a699fb00.json'\n",
"#filename = 'testdata/f76d97a5.json'\n",
"#filename = 'testdata/f5b8619d.json'\n",
"task = ajm.Task.load(filename)\n",
"image = task.pairs[0].input\n",
"image.show()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "8e2d17ed-0262-4915-a6e6-a5459b5a09ab",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"len(train_input_output) 12\n",
"len(test_input_output) 4\n"
]
}
],
"source": [
"from color_xy import color_to_xy\n",
"\n",
"# TODO: get it to work with size 30x30\n",
"IMAGE_SIZE = 28\n",
"\n",
"def obfuscate_image(image: ajm.Image, offset: float) -> np.ndarray:\n",
" # empty image with size: IMAGE_SIZE x IMAGE_SIZE\n",
" # each pixel is an array with 1 value: [color], where the color is a float between 0 and 1\n",
" # the color 1.0 is used to indicate when a pixel is outside the visible area.\n",
" rows2 = []\n",
" for y in range(0,IMAGE_SIZE):\n",
" columns2 = [[1.0]] * IMAGE_SIZE\n",
" rows2.append(columns2)\n",
" # assign obfuscated values\n",
" for row_index, rows in enumerate(image.pixels):\n",
" for column_index, pixel in enumerate(rows):\n",
" obfuscated_pixel = (float(pixel) + offset * 10.0) % 10.0\n",
" value = float(obfuscated_pixel) / 11.0\n",
" rows2[row_index][column_index] = [value]\n",
" obfuscated_image = np.array(rows2)\n",
" return obfuscated_image\n",
"\n",
"def numpy_image_to_tensors(obfuscated_image: np.ndarray, device: torch.device) -> torch.Tensor:\n",
" tensors = torch.from_numpy(obfuscated_image)\n",
" #print(tensors)\n",
" # cast it to 32-bit floating point tensor\n",
" tensors = tensors.type('torch.FloatTensor')\n",
" #print(tensors)\n",
" #print(\"before\", tensors.shape)\n",
" # change layout from: rows -> columns -> obfuscated_pixel_array\n",
" # change layout to: obfuscated_pixel_array -> rows -> columns\n",
" tensors = tensors.permute(2, 0, 1)\n",
" #print(\"after\", tensors.shape)\n",
" tensors_on_device = tensors.to(device)\n",
" return tensors_on_device\n",
" \n",
"all_images = []\n",
"for pair in task.pairs:\n",
" all_images.append(pair.input)\n",
" all_images.append(pair.output)\n",
"\n",
"train_input_output = []\n",
"test_input_output = []\n",
"number_of_offsets = 4\n",
"for i in range(0, number_of_offsets):\n",
" offset = float(i) / float(number_of_offsets)\n",
" if i == 0:\n",
" offset = 0.0\n",
" if i == 1:\n",
" offset = 0.25\n",
" if i == 2:\n",
" offset = 0.5\n",
" if i == 3:\n",
" offset = 0.75\n",
" if i == 4:\n",
" offset = 0.125\n",
" if i == 5:\n",
" offset = 0.375\n",
" if i == 6:\n",
" offset = 0.625\n",
" if i == 7:\n",
" offset = 0.330823\n",
" if i == 8:\n",
" offset = 0.23\n",
" if i == 9:\n",
" offset = 0.893\n",
" if i == 10:\n",
" offset = 0.01111\n",
" if i == 11:\n",
" offset = 0.71313\n",
" if i == 12:\n",
" offset = 0.91555\n",
" if i == 13:\n",
" offset = 0.51717\n",
" \n",
" for pair in task.pairs:\n",
" input_image = obfuscate_image(pair.input, offset)\n",
" output_image = obfuscate_image(pair.output, offset)\n",
" input_tensors = numpy_image_to_tensors(input_image, device)\n",
" output_tensors = numpy_image_to_tensors(output_image, device)\n",
" input_output_offset = (input_tensors, output_tensors, offset)\n",
" if pair.pair_type == ajm.PairType.TRAIN:\n",
" train_input_output.append(input_output_offset)\n",
" else:\n",
" test_input_output.append(input_output_offset)\n",
"print(\"len(train_input_output)\", len(train_input_output))\n",
"print(\"len(test_input_output)\", len(test_input_output))"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "45e2653e-3539-4b61-ade5-18a193c93616",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ConvAutoencoder(\n",
" (conv1): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
" (t_conv1): ConvTranspose2d(32, 16, kernel_size=(2, 2), stride=(2, 2))\n",
" (t_conv2): ConvTranspose2d(16, 1, kernel_size=(2, 2), stride=(2, 2))\n",
")\n",
"----------------------------------------------------------------\n",
" Layer (type) Output Shape Param #\n",
"================================================================\n",
" Conv2d-1 [-1, 16, 30, 30] 160\n",
" MaxPool2d-2 [-1, 16, 15, 15] 0\n",
" Conv2d-3 [-1, 32, 15, 15] 4,640\n",
" MaxPool2d-4 [-1, 32, 7, 7] 0\n",
" ConvTranspose2d-5 [-1, 16, 14, 14] 2,064\n",
" ConvTranspose2d-6 [-1, 1, 28, 28] 65\n",
"================================================================\n",
"Total params: 6,929\n",
"Trainable params: 6,929\n",
"Non-trainable params: 0\n",
"----------------------------------------------------------------\n",
"Input size (MB): 0.00\n",
"Forward/backward pass size (MB): 0.23\n",
"Params size (MB): 0.03\n",
"Estimated Total Size (MB): 0.26\n",
"----------------------------------------------------------------\n"
]
}
],
"source": [
"import torch.nn as nn\n",
"import torch.nn.functional as F\n",
"\n",
"# define the NN architecture\n",
"class ConvAutoencoder(nn.Module):\n",
" def __init__(self):\n",
" super(ConvAutoencoder, self).__init__()\n",
" ## encoder layers ##\n",
" # conv layer (depth from 2 --> 16), 3x3 kernels\n",
" self.conv1 = nn.Conv2d(1, 16, 3, padding=1) \n",
" # conv layer (depth from 16 --> 4), 3x3 kernels\n",
" self.conv2 = nn.Conv2d(16, 32, 3, padding=1)\n",
" # pooling layer to reduce x-y dims by two; kernel and stride of 2\n",
" self.pool = nn.MaxPool2d(2, 2)\n",
" \n",
" ## decoder layers ##\n",
" ## a kernel of 2 and a stride of 2 will increase the spatial dims by 2\n",
" self.t_conv1 = nn.ConvTranspose2d(32, 16, 2, stride=2)\n",
" self.t_conv2 = nn.ConvTranspose2d(16, 1, 2, stride=2)\n",
"\n",
"\n",
" def forward(self, x):\n",
" ## encode ##\n",
" # add hidden layers with relu activation function\n",
" # and maxpooling after\n",
" x = F.relu(self.conv1(x))\n",
" x = self.pool(x)\n",
" # add second hidden layer\n",
" x = F.relu(self.conv2(x))\n",
" x = self.pool(x) # compressed representation\n",
" \n",
" ## decode ##\n",
" # add transpose conv layers, with relu activation function\n",
" x = F.relu(self.t_conv1(x))\n",
" # output layer (with sigmoid for scaling from 0 to 1)\n",
" x = F.sigmoid(self.t_conv2(x))\n",
" \n",
" return x\n",
"\n",
"# initialize the NN\n",
"model = ConvAutoencoder()\n",
"print(model)\n",
"summary(model,input_size=(1,30,30))\n",
"model = model.to(device)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "32898b91-a8f1-47f0-9a75-ea7917f05f72",
"metadata": {},
"outputs": [],
"source": [
"# specify loss function\n",
"criterion = nn.MSELoss()\n",
"#criterion = nn.L1Loss()\n",
"#criterion = nn.CrossEntropyLoss()\n",
"#criterion = nn.KLDivLoss()\n",
"#criterion = nn.BCELoss()\n",
"#criterion = nn.BCEWithLogitsLoss()\n",
"\n",
"# specify loss function\n",
"optimizer = torch.optim.Adam(model.parameters(), lr=0.001)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "24fa3733-aaed-49a8-883b-408aac441ebf",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 44.88it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 1 \tTraining Loss: 0.206634\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 188.17it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 2 \tTraining Loss: 0.166242\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 184.55it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 3 \tTraining Loss: 0.093574\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 190.64it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 4 \tTraining Loss: 0.042907\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 191.49it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 5 \tTraining Loss: 0.037412\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 200.09it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 6 \tTraining Loss: 0.035057\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 195.69it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 7 \tTraining Loss: 0.030930\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 192.32it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 8 \tTraining Loss: 0.027219\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 184.89it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 9 \tTraining Loss: 0.023562\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 191.68it/s]"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 10 \tTraining Loss: 0.019988\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"\n"
]
}
],
"source": [
"import random\n",
"#random.Random(42).shuffle(train_input_output)\n",
"\n",
"# number of epochs to train the model\n",
"n_epochs = 10\n",
"\n",
"for epoch in range(1, n_epochs+1):\n",
" # monitor training loss\n",
" train_loss = 0.0\n",
"\n",
" #random.Random(epoch).shuffle(train_input_output)\n",
" \n",
" ###################\n",
" # train the model #\n",
" ###################\n",
" for input_output_offset in tqdm(train_input_output):\n",
" input, expected_output, _ = input_output_offset\n",
" \n",
" # clear the gradients of all optimized variables\n",
" optimizer.zero_grad()\n",
" # forward pass: compute predicted outputs by passing inputs to the model\n",
"\n",
" outputs = model(input)\n",
" # calculate the loss\n",
" loss = criterion(outputs, expected_output)\n",
" # backward pass: compute gradient of the loss with respect to model parameters\n",
" loss.backward()\n",
" # perform a single optimization step (parameter update)\n",
" optimizer.step()\n",
" # update running training loss\n",
" train_loss += loss.item()*input.size(0)\n",
" \n",
" # print avg training statistics \n",
" train_loss = train_loss/len(train_input_output)\n",
" print('Epoch: {} \\tTraining Loss: {:.6f}'.format(\n",
" epoch, \n",
" train_loss\n",
" ))"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "2ed1d86b-8cce-4ce6-be89-7a2e7a325d23",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 500x500 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# obtain one batch of test images\n",
"dataiter = iter(test_input_output)\n",
"input, expected_output, offset = next(dataiter)\n",
"\n",
"# get sample outputs\n",
"output = model(input)\n",
"\n",
"output_tensor = output.cpu().detach()\n",
"#print(\"output_tensor.shape\", output_tensor.shape)\n",
"output_tensor = output_tensor.permute(1, 2, 0)\n",
"#print(\"output_tensor.shape\", output_tensor.shape)\n",
"output_numpy = output_tensor.numpy()\n",
"#print(\"output_numpy.shape\", output_numpy.shape)\n",
"\n",
"from color_xy import xy_to_color\n",
"\n",
"deobfuscated = []\n",
"COLOR_UNDEFINED = 10\n",
"for y in range(0,IMAGE_SIZE):\n",
" columns2 = [COLOR_UNDEFINED] * IMAGE_SIZE\n",
" deobfuscated.append(columns2)\n",
"adjustment = int(offset * 10.0)\n",
"for row_index, row in enumerate(output_numpy):\n",
" #print(\"row_index\", row_index)\n",
" for column_index, pixel_data in enumerate(row):\n",
" color_float = pixel_data[0]\n",
" color_int = (int(color_float * 11.0) + 10 - adjustment) % 10\n",
" if color_float >= 0.99:\n",
" color_int = 10\n",
" deobfuscated[row_index][column_index] = color_int\n",
"\n",
"pixels = np.array(deobfuscated, np.int32)\n",
"result = ajm.Image(pixels, \"predicted\")\n",
"result.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "789a56c4-e809-462c-8a02-ad6fff0922c0",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.11.4"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
|