File size: 54,492 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 555 556 557 558 559 560 561 562 |
{
"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": 83,
"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": 102,
"id": "8e2d17ed-0262-4915-a6e6-a5459b5a09ab",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"len(train_input_output) 9\n",
"len(test_input_output) 3\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 the 2 obfuscated [x,y] values\n",
" rows2 = []\n",
" for y in range(0,IMAGE_SIZE):\n",
" columns2 = [[0.0, 0.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",
" xy = color_to_xy(pixel, 10, offset)\n",
" rows2[row_index][column_index] = xy\n",
" obfuscated_image = np.array(rows2)\n",
" return obfuscated_image\n",
"\n",
"def onehot_image(image: ajm.Image, offset: float) -> np.ndarray:\n",
" offset_int = int(offset * 10.0)\n",
" # empty image with size: IMAGE_SIZE x IMAGE_SIZE\n",
" # each pixel is an array with the 10 values either 0 or 1\n",
" ten_zeros = [0] * 10\n",
" rows2 = []\n",
" for y in range(0,IMAGE_SIZE):\n",
" columns2 = [ten_zeros] * 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",
" onehot_index = (pixel + offset_int) % 10\n",
" rows2[row_index][column_index][onehot_index] = 1\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 = 3\n",
"for i in range(0, number_of_offsets):\n",
" offset = float(i) / float(number_of_offsets)\n",
" if i == 0:\n",
" offset = 0.01111\n",
" if i == 1:\n",
" offset = 0.71313\n",
" if i == 2:\n",
" offset = 0.91555\n",
" if i == 3:\n",
" offset = 0.51717\n",
" if i == 4:\n",
" offset = 0.330823\n",
" if i == 5:\n",
" offset = 0.23\n",
" if i == 6:\n",
" offset = 0.893\n",
" \n",
" for pair in task.pairs:\n",
" #input_image = obfuscate_image(pair.input, offset)\n",
" input_image = onehot_image(pair.input, offset)\n",
" #output_image = obfuscate_image(pair.output, offset)\n",
" output_image = onehot_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": 103,
"id": "45e2653e-3539-4b61-ade5-18a193c93616",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ConvAutoencoder(\n",
" (conv1): Conv2d(10, 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, 10, kernel_size=(2, 2), stride=(2, 2))\n",
")\n",
"----------------------------------------------------------------\n",
" Layer (type) Output Shape Param #\n",
"================================================================\n",
" Conv2d-1 [-1, 16, 30, 30] 1,456\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, 10, 28, 28] 650\n",
"================================================================\n",
"Total params: 8,810\n",
"Trainable params: 8,810\n",
"Non-trainable params: 0\n",
"----------------------------------------------------------------\n",
"Input size (MB): 0.03\n",
"Forward/backward pass size (MB): 0.29\n",
"Params size (MB): 0.03\n",
"Estimated Total Size (MB): 0.36\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(10, 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, 10, 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=(2,30,30))\n",
"summary(model,input_size=(10,30,30))\n",
"model = model.to(device)"
]
},
{
"cell_type": "code",
"execution_count": 104,
"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": 107,
"id": "24fa3733-aaed-49a8-883b-408aac441ebf",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 127.24it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 1 \tTraining Loss: 0.748481\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 152.52it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 2 \tTraining Loss: 0.716186\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 172.92it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 3 \tTraining Loss: 0.687404\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 193.68it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 4 \tTraining Loss: 0.661680\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 196.24it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 5 \tTraining Loss: 0.636713\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 189.97it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 6 \tTraining Loss: 0.612834\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 192.99it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 7 \tTraining Loss: 0.588938\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 189.74it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 8 \tTraining Loss: 0.564912\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 185.56it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 9 \tTraining Loss: 0.541787\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 192.00it/s]"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 10 \tTraining Loss: 0.519482\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": 108,
"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",
"\n",
"offset_int = int(offset * 10.0)\n",
"for row_index, row in enumerate(output_numpy):\n",
" #print(\"row_index\", row_index)\n",
" for column_index, xy in enumerate(row):\n",
" color_index = np.argmax(xy)\n",
" color_index = (color_index + 10 - offset_int) % 10\n",
" deobfuscated[row_index][column_index] = color_index\n",
" #x, y = xy\n",
" #distance = x * x + y * y\n",
" #if distance > 0.35 and distance < 1.5:\n",
" # color = xy_to_color((x, y), 10, offset)\n",
" # deobfuscated[row_index][column_index] = color\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
}
|